text:
Background: #fff
Foreground: #000
PrimaryPale: #8cf
PrimaryLight: #18f
PrimaryMid: #04b
PrimaryDark: #014
SecondaryPale: #ffc
SecondaryLight: #fe8
SecondaryMid: #db4
SecondaryDark: #841
TertiaryPale: #eee
TertiaryLight: #ccc
TertiaryMid: #999
TertiaryDark: #666
Error: #f88

To get started with this blank [[TiddlyWiki]], you'll need to modify the following tiddlers:
* [[SiteTitle]] & [[SiteSubtitle]]: The title and subtitle of the site, as shown above (after saving, they will also appear in the browser title bar)
* [[DefaultTiddlers]]: Contains the names of the tiddlers that you want to appear when the TiddlyWiki is opened

<<importTiddlers>>

These [[InterfaceOptions]] for customising [[TiddlyWiki]] are saved in your browser

<<option chkSaveBackups>> [[SaveBackups]]
<<option chkAutoSave>> [[AutoSave]]
<<option chkRegExpSearch>> [[RegExpSearch]]
<<option chkCaseSensitiveSearch>> [[CaseSensitiveSearch]]
<<option chkAnimate>> [[EnableAnimations]]

----

/*{{{*/
body {background:[[ColorPalette::Background]]; color:[[ColorPalette::Foreground]];}

a {color:[[ColorPalette::PrimaryMid]];}
a:hover {background-color:[[ColorPalette::PrimaryMid]]; color:[[ColorPalette::Background]];}
a img {border:0;}

h1,h2,h3,h4,h5,h6 {color:[[ColorPalette::SecondaryDark]]; background:transparent;}
h1 {border-bottom:2px solid [[ColorPalette::TertiaryLight]];}
h2,h3 {border-bottom:1px solid [[ColorPalette::TertiaryLight]];}

.button {color:[[ColorPalette::PrimaryDark]]; border:1px solid [[ColorPalette::Background]];}
.button:hover {color:[[ColorPalette::PrimaryDark]]; background:[[ColorPalette::SecondaryLight]]; border-color:[[ColorPalette::SecondaryMid]];}
.button:active {color:[[ColorPalette::Background]]; background:[[ColorPalette::SecondaryMid]]; border:1px solid [[ColorPalette::SecondaryDark]];}

.tabSelected {color:[[ColorPalette::PrimaryDark]];
background:[[ColorPalette::TertiaryPale]];
border-left:1px solid [[ColorPalette::TertiaryLight]];
border-top:1px solid [[ColorPalette::TertiaryLight]];
border-right:1px solid [[ColorPalette::TertiaryLight]];
}
.tabUnselected {color:[[ColorPalette::Background]]; background:[[ColorPalette::TertiaryMid]];}
.tabContents {color:[[ColorPalette::PrimaryDark]]; background:[[ColorPalette::TertiaryPale]]; border:1px solid [[ColorPalette::TertiaryLight]];}
.tabContents .button {border:0;}

#sidebar {}
#sidebarOptions input {border:1px solid [[ColorPalette::PrimaryMid]];}
#sidebarOptions .sliderPanel {background:[[ColorPalette::PrimaryPale]];}
#sidebarOptions .sliderPanel a {border:none;color:[[ColorPalette::PrimaryMid]];}
#sidebarOptions .sliderPanel a:hover {color:[[ColorPalette::Background]]; background:[[ColorPalette::PrimaryMid]];}
#sidebarOptions .sliderPanel a:active {color:[[ColorPalette::PrimaryMid]]; background:[[ColorPalette::Background]];}

.wizard {background:[[ColorPalette::PrimaryPale]]; border:1px solid [[ColorPalette::PrimaryMid]];}
.wizard h1 {color:[[ColorPalette::PrimaryDark]]; border:none;}
.wizard h2 {color:[[ColorPalette::Foreground]]; border:none;}
.wizardStep {background:[[ColorPalette::Background]]; color:[[ColorPalette::Foreground]];
border:1px solid [[ColorPalette::PrimaryMid]];}
.wizardStep.wizardStepDone {background:[[ColorPalette::TertiaryLight]];}
.wizardFooter {background:[[ColorPalette::PrimaryPale]];}
.wizardFooter .status {background:[[ColorPalette::PrimaryDark]]; color:[[ColorPalette::Background]];}
.wizard .button {color:[[ColorPalette::Foreground]]; background:[[ColorPalette::SecondaryLight]]; border: 1px solid;
border-color:[[ColorPalette::SecondaryPale]] [[ColorPalette::SecondaryDark]] [[ColorPalette::SecondaryDark]] [[ColorPalette::SecondaryPale]];}
.wizard .button:hover {color:[[ColorPalette::Foreground]]; background:[[ColorPalette::Background]];}
.wizard .button:active {color:[[ColorPalette::Background]]; background:[[ColorPalette::Foreground]]; border: 1px solid;
border-color:[[ColorPalette::PrimaryDark]] [[ColorPalette::PrimaryPale]] [[ColorPalette::PrimaryPale]] [[ColorPalette::PrimaryDark]];}

.wizard .notChanged {background:transparent;}
.wizard .changedLocally {background:#80ff80;}
.wizard .changedServer {background:#8080ff;}
.wizard .changedBoth {background:#ff8080;}
.wizard .notFound {background:#ffff80;}
.wizard .putToServer {background:#ff80ff;}
.wizard .gotFromServer {background:#80ffff;}

#messageArea {border:1px solid [[ColorPalette::SecondaryMid]]; background:[[ColorPalette::SecondaryLight]]; color:[[ColorPalette::Foreground]];}
#messageArea .button {color:[[ColorPalette::PrimaryMid]]; background:[[ColorPalette::SecondaryPale]]; border:none;}

.popupTiddler {background:[[ColorPalette::TertiaryPale]]; border:2px solid [[ColorPalette::TertiaryMid]];}

.popup {background:[[ColorPalette::TertiaryPale]]; color:[[ColorPalette::TertiaryDark]]; border-left:1px solid [[ColorPalette::TertiaryMid]]; border-top:1px solid [[ColorPalette::TertiaryMid]]; border-right:2px solid [[ColorPalette::TertiaryDark]]; border-bottom:2px solid [[ColorPalette::TertiaryDark]];}
.popup hr {color:[[ColorPalette::PrimaryDark]]; background:[[ColorPalette::PrimaryDark]]; border-bottom:1px;}
.popup li.disabled {color:[[ColorPalette::TertiaryMid]];}
.popup li a, .popup li a:visited {color:[[ColorPalette::Foreground]]; border: none;}
.popup li a:hover {background:[[ColorPalette::SecondaryLight]]; color:[[ColorPalette::Foreground]]; border: none;}
.popup li a:active {background:[[ColorPalette::SecondaryPale]]; color:[[ColorPalette::Foreground]]; border: none;}
.popupHighlight {background:[[ColorPalette::Background]]; color:[[ColorPalette::Foreground]];}
.listBreak div {border-bottom:1px solid [[ColorPalette::TertiaryDark]];}

.tiddler .defaultCommand {font-weight:bold;}

.title {color:[[ColorPalette::SecondaryDark]];}
.subtitle {color:[[ColorPalette::TertiaryDark]];}

.toolbar {color:[[ColorPalette::PrimaryMid]];}
.toolbar a {color:[[ColorPalette::TertiaryLight]];}
.selected .toolbar a {color:[[ColorPalette::TertiaryMid]];}
.selected .toolbar a:hover {color:[[ColorPalette::Foreground]];}

.tagging, .tagged {border:1px solid [[ColorPalette::TertiaryPale]]; background-color:[[ColorPalette::TertiaryPale]];}
.selected .tagging, .selected .tagged {background-color:[[ColorPalette::TertiaryLight]]; border:1px solid [[ColorPalette::TertiaryMid]];}
.tagging .listTitle, .tagged .listTitle {color:[[ColorPalette::PrimaryDark]];}
.tagging .button, .tagged .button {border:none;}

.footer {color:[[ColorPalette::TertiaryLight]];}
.selected .footer {color:[[ColorPalette::TertiaryMid]];}

.error, .errorButton {color:[[ColorPalette::Foreground]]; background:[[ColorPalette::Error]];}
.warning {color:[[ColorPalette::Foreground]]; background:[[ColorPalette::SecondaryPale]];}
.lowlight {background:[[ColorPalette::TertiaryLight]];}

.zoomer {background:none; color:[[ColorPalette::TertiaryMid]]; border:3px solid [[ColorPalette::TertiaryMid]];}

.annotation {background:[[ColorPalette::SecondaryLight]]; color:[[ColorPalette::Foreground]]; border:2px solid [[ColorPalette::SecondaryMid]];}

.viewer .listTitle {list-style-type:none; margin-left:-2em;}
.viewer .button {border:1px solid [[ColorPalette::SecondaryMid]];}
.viewer blockquote {border-left:3px solid [[ColorPalette::TertiaryDark]];}

.viewer table, table.twtable {border:2px solid [[ColorPalette::TertiaryDark]];}
.viewer th, .viewer thead td, .twtable th, .twtable thead td {background:[[ColorPalette::SecondaryMid]]; border:1px solid [[ColorPalette::TertiaryDark]]; color:[[ColorPalette::Background]];}
.viewer td, .viewer tr, .twtable td, .twtable tr {border:1px solid [[ColorPalette::TertiaryDark]];}

.viewer pre {border:1px solid [[ColorPalette::SecondaryLight]]; background:[[ColorPalette::SecondaryPale]];}
.viewer code {color:[[ColorPalette::SecondaryDark]];}
.viewer hr {border:0; border-top:dashed 1px [[ColorPalette::TertiaryDark]]; color:[[ColorPalette::TertiaryDark]];}

.highlight, .marked {background:[[ColorPalette::SecondaryLight]];}

.editor input {border:1px solid [[ColorPalette::PrimaryMid]];}
.editor textarea {border:1px solid [[ColorPalette::PrimaryMid]]; width:100%;}
.editorFooter {color:[[ColorPalette::TertiaryMid]];}

#backstageArea {background:[[ColorPalette::Foreground]]; color:[[ColorPalette::TertiaryMid]];}
#backstageArea a {background:[[ColorPalette::Foreground]]; color:[[ColorPalette::Background]]; border:none;}
#backstageArea a:hover {background:[[ColorPalette::SecondaryLight]]; color:[[ColorPalette::Foreground]]; }
#backstageArea a.backstageSelTab {background:[[ColorPalette::Background]]; color:[[ColorPalette::Foreground]];}
#backstageButton a {background:none; color:[[ColorPalette::Background]]; border:none;}
#backstageButton a:hover {background:[[ColorPalette::Foreground]]; color:[[ColorPalette::Background]]; border:none;}
#backstagePanel {background:[[ColorPalette::Background]]; border-color: [[ColorPalette::Background]] [[ColorPalette::TertiaryDark]] [[ColorPalette::TertiaryDark]] [[ColorPalette::TertiaryDark]];}
.backstagePanelFooter .button {border:none; color:[[ColorPalette::Background]];}
.backstagePanelFooter .button:hover {color:[[ColorPalette::Foreground]];}
#backstageCloak {background:[[ColorPalette::Foreground]]; opacity:0.6; filter:alpha(opacity=60);}
/*}}}*/

/*{{{*/
* html .tiddler {height:1%;}

h1,h2,h3,h4,h5,h6 {font-weight:bold; text-decoration:none;}
h4,h5,h6 {margin-top:1em;}
h1 {font-size:1.35em;}
h2 {font-size:1.25em;}
h3 {font-size:1.1em;}
h4 {font-size:1em;}
h5 {font-size:.9em;}

hr {height:1px;}

a {text-decoration:none;}

dt {font-weight:bold;}

ol {list-style-type:decimal;}
ol ol {list-style-type:lower-alpha;}
ol ol ol {list-style-type:lower-roman;}
ol ol ol ol {list-style-type:decimal;}
ol ol ol ol ol {list-style-type:lower-alpha;}
ol ol ol ol ol ol {list-style-type:lower-roman;}
ol ol ol ol ol ol ol {list-style-type:decimal;}

.txtOptionInput {width:11em;}

#contentWrapper .chkOptionInput {border:0;}

.indent {margin-left:3em;}
.outdent {margin-left:3em; text-indent:-3em;}
code.escaped {white-space:nowrap;}

/* the 'a' is required for IE, otherwise it renders the whole tiddler in bold */

.siteTitle {font-size:3em;}
.siteSubtitle {font-size:1.2em;}

#sidebar {position:absolute; right:3px; width:16em; font-size:.9em;}
#sidebarOptions a {margin:0 0.2em; padding:0.2em 0.3em; display:block;}
#sidebarOptions input {margin:0.4em 0.5em;}
#sidebarOptions .sliderPanel a {font-weight:bold; display:inline; padding:0;}
#sidebarOptions .sliderPanel input {margin:0 0 0.3em 0;}
#sidebarTabs .tabContents {width:15em; overflow:hidden;}

.wizard h1 {font-size:2em; font-weight:bold; background:none; padding:0; margin:0.4em 0 0.2em;}
.wizard h2 {font-size:1.2em; font-weight:bold; background:none; padding:0; margin:0.4em 0 0.2em;}
.wizard .button {margin:0.5em 0 0; font-size:1.2em;}

#messageArea {position:fixed; top:2em; right:0; margin:0.5em; padding:0.5em; z-index:2000; _position:absolute;}
#messageArea a {text-decoration:underline;}

.popupTiddler {position: absolute; z-index:300; padding:1em; margin:0;}

.popup {position:absolute; z-index:300; font-size:.9em; padding:0; list-style:none; margin:0;}
.popup hr {display:block; height:1px; width:auto; padding:0; margin:0.2em 0;}
.popup li a {display:block; padding:0.4em; font-weight:normal; cursor:pointer;}
.listBreak {font-size:1px; line-height:1px;}
.listBreak div {margin:2px 0;}

.tab {margin:0 0 0 0.25em; padding:2px;}
.tabContents ul, .tabContents ol {margin:0; padding:0;}
.txtMainTab .tabContents li {list-style:none;}

#contentWrapper {display:block;}
#splashScreen {display:none;}

#displayArea {margin:1em 17em 0 14em;}

.toolbar {text-align:right; font-size:.9em;}

.missing .viewer,.missing .title {font-style:italic;}

.title {font-size:1.6em; font-weight:bold;}

.missing .subtitle {display:none;}
.subtitle {font-size:1.1em;}

.tagging {margin:0.5em 0.5em 0.5em 0; float:left; display:none;}
.isTag .tagging {display:block;}
.tagged {margin:0.5em; float:right;}
.tagging ul, .tagged ul {list-style:none; margin:0.25em; padding:0;}
.tagClear {clear:both;}

.footer {font-size:.9em;}
.footer li {display:inline;}

* html .viewer pre {width:99%; padding:0 0 1em 0;}
.viewer .button {margin:0 0.25em; padding:0 0.25em;}
.viewer ul, .viewer ol {margin-left:0.5em; padding-left:1.5em;}

.viewer table, table.twtable {border-collapse:collapse; margin:0.8em 1.0em;}
.viewer th, .viewer td, .viewer tr,.viewer caption,.twtable th, .twtable td, .twtable tr,.twtable caption {padding:3px;}
table.listView {font-size:0.85em; margin:0.8em 1.0em;}
table.listView th, table.listView td, table.listView tr {padding:0 3px 0 3px;}

.viewer pre {padding:0.5em; margin-left:0.5em; font-size:1.2em; line-height:1.4em; overflow:auto;}
.viewer code {font-size:1.2em; line-height:1.4em;}

.editor {font-size:1.1em;}
.editor input, .editor textarea {display:block; width:100%; font:inherit;}

.zoomer {font-size:1.1em; position:absolute; overflow:hidden;}

* html #backstage {width:99%;}
* html #backstageArea {width:99%;}
#backstageArea {display:none; position:relative; overflow: hidden; z-index:150; padding:0.3em 0.5em;}
#backstageToolbar {position:relative;}
#backstageArea a {font-weight:bold; margin-left:0.5em; padding:0.3em 0.5em;}
#backstageButton {display:none; position:absolute; z-index:175; top:0; right:0;}
#backstage {position:relative; width:100%; z-index:50;}
#backstagePanel {display:none; z-index:100; position:absolute; width:90%; margin-left:3em; padding:1em;}
#backstageCloak {display:none; z-index:20; position:absolute; width:100%; height:100px;}

.whenBackstage {display:none;}
.backstageVisible .whenBackstage {display:block;}
/*}}}*/

/***
StyleSheet for use when a translation requires any css style changes.
This StyleSheet can be used directly by languages such as Chinese, Japanese and Korean which need larger font sizes.
***/
/*{{{*/
body {font-size:0.8em;}
#sidebarOptions {font-size:1.05em;}
#sidebarOptions a {font-style:normal;}
#sidebarOptions .sliderPanel {font-size:0.95em;}
.subtitle {font-size:0.8em;}
.viewer table.listView {font-size:0.95em;}
/*}}}*/

/*{{{*/
@media print {
#mainMenu, #sidebar, #messageArea, .toolbar, #backstageButton, #backstageArea {display: none !important;}
#displayArea {margin: 1em 1em 0em;}
noscript {display:none;} /* Fixes a feature in Firefox 1.5.0.2 where print preview displays the noscript content */
}
/*}}}*/

,  ( )

/***
|''Name''|RefreshTiddlerCommand|
|''Version''|0.3.0|
***/
//{{{
(function($) { var cmd = config.commands.refreshTiddler = { text: "refresh", locale: { refreshing: "Refreshing tiddler..." }, tooltip: "refresh this tiddler to be the one on the server", handler: function(ev, src, title) { var tiddler = store.getTiddler(title); if(!tiddler) { tiddler = new Tiddler(title); merge(tiddler.fields, config.defaultCustomFields); }$(story.getTiddler(title)).find(".viewer").
empty().text(cmd.locale.refreshing);
var dirtyStatus = store.isDirty();
"server.workspace": tiddler.fields["server.recipe"]  ? "recipes/" + tiddler.fields["server.recipe"] :
tiddler.fields["server.workspace"] || "bags/"+tiddler.fields["server.bag"],
"server.host": tiddler.fields["server.host"],
"server.type": tiddler.fields["server.type"]
}, function() {
store.setDirty(dirtyStatus);
});
}
};

})(jQuery);
//}}}

OK I admit that that last phrase was not wholly precise, but its meaning is the following obvious one:
given a sequence $$(x_1,\dots,x_r)$$ with $$r\geq k$$, and writing $$x=(x_1,\dots,x_k)$$, you do whatever $$\sigma'$$ would do to the sequence $$(\sigma,x,x_3,\dots,x_r)$$.)

<svg xmlns="http://www.w3.org/2000/svg" xmlns:xl="http://www.w3.org/1999/xlink" version="1.1" viewBox="72 648 70 70"
width="30" height="30">
<g stroke="none" stroke-opacity="1" stroke-dasharray="none" fill="none" fill-opacity="1">
<g>
<path d="M 77.59005 669.34003 C 71.532745 681.90424 73.714462 697.4441 84.135193 707.86475
C 97.315445 721.0451 118.684715 721.0451 131.8649 707.86475
C 145.04515 694.68457 145.04515 673.31537 131.8649 660.13513
C 121.4441 649.7141 105.90419 647.53253 93.339905 653.5899 L 102.047455 662.2976
C 109.58637 660.2373 117.987976 662.16803 123.90997 668.08997
C 132.69673 676.8767 132.69673 691.12317 123.90997 699.90985
C 115.12313 708.6966 100.87699 708.6966 92.09012 699.90985
C 86.168266 693.98804 84.23744 685.58643 86.297653 678.04755 Z M 72 648 L 72 668.25 L 78.75 661.49957
L 99.00019 681.7502 L 105.750175 675.00006 L 85.50013 654.75012 L 92.249985 648 Z" fill="black"
class="glyph"/>
</g>
</g>
</svg>
A [[SiteIcon|SiteIcon tiddler]]@glossary helps provide some identity to your space.  Ideally it'd be a square and a minimum of 48*48 pixels size.  You can upload your site icon using the uploader below.

<<binaryUploadPublic title:SiteIcon>>
!!Parent page

We are trying to [[find an efficient lift by imitating Martin's proof and using an iterative procedure|Can we find an efficient lift by imitating Martin's proof and using an iterative procedure?]].

!Introduction

We have been led to the following definition of a lift. Let $$A$$ be the set $$\{x\in X:\forall i\ x_i\in\Delta_i\}$$. I now want to define a lift $$\pi:Y\to X$$ as follows. Define a quasistrategy to be //simple// if it is the canonical strategy for avoiding some set $$U$$ of restrictions of the form $$x_i\notin\Delta_i$$. $$Y$$ will consist of sequences of the form $$((\gamma_1,W),(\gamma_2,W),\dots,(\gamma_{n/2},W),(\gamma_{n/2+1},\bullet),\dots,(\gamma_n,\bullet))$$, with the following properties.
#$$W$$ is the winning set for some simple quasistrategy.
#''either'' $$\bullet$$ is the winning set $$V$$ for some simple quasistrategy for Player II for the shrinking-neighbourhoods game inside $$W$$, and $$V\subset A$$, ''or'' $$\bullet$$ is a set of coordinate restrictions of the form $$x_i\notin\Delta_i$$ that is consistent with $$W$$.
#If $$\bullet$$ is a simple winning set $$V\subset A$$, then the sequence $$x=(\gamma_1,\dots,\gamma_n)$$ belongs to $$V$$. If $$\bullet$$ is a set of coordinate restrictions, then $$x$$ obeys those restrictions.
The question at this point is whether the lift just described is a Ramsey lift.

!An attempt to prove that this is a Ramsey lift, by imitating Martin's argument

Let $$Z$$ be a winning set for Player I in $$Y$$ and let $$\sigma$$ be a winning strategy for getting into $$Z$$. We must describe a winning strategy in $$X$$ for Player I to get into $$\pi(Z)$$.

The basic technique of Martin is to imagine that Player I decides how to play in $$X$$ by imagining an auxiliary game in $$Y$$ and playing the projections of the moves. The complication is that she cannot rely on Player II to cooperate with this, which sometimes means that she has to go back and change her mind about what she deems Player II to have played in the auxiliary game.

Now let us give slightly more detail. Suppose that according to the strategy $$\sigma$$, Player I starts the auxiliary game with the move $$y_i=(\gamma_i,W)$$. Then she starts the real game with the specification $$x_i=\gamma_i$$. She then defines $$U$$ to be the set of all ...

I got stuck at that point, because I had not been clear in my definition of a simple quasistrategy. I said it was the canonical quasistrategy for avoiding a set of restrictions of a certain form. But what does that mean? Does it mean avoiding a move of the form $$x_i=\gamma_i$$ with $$\gamma_i\notin\Delta_i$$ or does it mean avoiding ending up with a sequence that obeys one of those restrictions? Since we are talking about winning sets rather than games, it should almost certainly mean the latter.

!Reintroduction

For clarity's sake let me state the definition of the lift once more.

Let $$A$$ be the set $$\{x\in X:\forall i\ x_i\in\Delta_i\}$$. I now want to define a lift $$\pi:Y\to X$$ as follows.
Let $$\mathcal{U}(A)$$ be the class of 1-open sets of the form $$\{x\in X:\exists i\in I\ x\notin\Delta_i\}$$. That is, it is the class of 1-open sets that can be formed by taking some subset of the coordinate restrictions that characterize points in $$A^c$$.

Define a quasistrategy $$\sigma$$ to be //simple// if there is some $$U\in\mathcal{U}(A)$$ such that $$\sigma$$ is the canonical strategy for avoiding $$U$$. $$Y$$ consists of sequences of the form $$((\gamma_1,W),(\gamma_2,W),\dots,(\gamma_{n/2},W),(\gamma_{n/2+1},\bullet),\dots,(\gamma_n,\bullet))$$, with the following properties.
#$$W$$ is the winning set for some simple quasistrategy.
#''either'' $$\bullet$$ is the winning set $$V$$ for some simple quasistrategy for Player II for the shrinking-neighbourhoods game inside $$W$$, and $$V\subset A$$, ''or'' $$\bullet$$ is a set in $$\mathcal{U}(A)$$ that has a non-empty intersection with $$W$$.
#If $$\bullet$$ is a simple winning set $$V\subset A$$, then the sequence $$x=(\gamma_1,\dots,\gamma_n)$$ belongs to $$V$$. If $$\bullet$$ is a set in $$\mathcal{U}(A)$$, then $$x$$ belongs to that set.

!An attempt at a proof

Let $$Z$$ be a winning set for Player I in $$Y$$ and let $$\sigma$$ be a winning strategy for getting into $$Z$$. We must describe a winning strategy in $$X$$ for Player I to get into $$\pi(Z)$$. Suppose that according to the strategy $$\sigma$$, Player I starts the auxiliary game with the move $$y_i=(\gamma_i,W)$$. Then she starts the real game with the specification $$x_i=\gamma_i$$. She then defines $$U$$ to be $$W\cap A^c$$. If she has a winning strategy for reaching a point in $$U$$, then she plays that strategy, and deems Player II to have declared that set $$U$$ (which belongs to $$\mathcal{U}(A)$$ and has non-empty intersection with $$W$$) as his $$\bullet$$. If she does not have a winning strategy for reaching a point in $$U$$, then she plays the auxiliary game as though Player II has declared the winning set $$V$$ for the canonical quasistrategy for avoiding $$U$$. If at any stage Player II plays inconsistently with that declaration, then Player I has a winning strategy for getting into $$U$$ and can revert to the first plan.

I now see that the above proof, which I was suspicious of, is indeed mistaken. The problem is that because the second kind of $$\bullet$$ is not an actual specification of a sequence (as it is in Martin's proof), it is not trivial that by arriving at a sequence in $$U$$ Player I is creating a point that is the projection of some run of $$\sigma$$. Or at least, I don't feel as though I have written the proof out in sufficient detail to be sure that I have not overlooked something important.

Let me try again to say what Player I's strategy is in the real game for reaching a point in $$\pi(Z)$$. Let $$U$$ be defined as above. Then $$\sigma$$ tells Player I to react in a certain way to $$U$$. But in the auxiliary game, if Player II has declared the set $$U$$, then both players are obliged to play in a way that will lead to the eventual sequence being in $$U$$, so Player I does not have to play a //winning// strategy for ending up in $$U$$.

It looks, therefore, as though the following situation could occur. Player I might play as though Player II has declared $$U$$ in the auxiliary game, but Player II might in the real game play in a way that forces the eventual sequence //not// to lie in $$U$$. To put that differently, although in the real game Player I has a winning strategy for ending up in $$U$$, it is not obvious that she can actually //use// that strategy -- or rather, she can use it, but it is not obvious that if she uses it then the end position will be the projection of the end position of some play of the auxiliary game.

!Conclusion

I'm fairly sure that this shows that the suggested simplification does //not// work. That is actually a relief, because as far as I can tell it would have led to a conclusion that I do not want to be true: that we can efficiently lift a 2-basic set to a 1-basic set. (See the end of [[this page|How easy is it to lift a 2-basic set to a 1-basic set?]] for an explanation of why I do not want this to be true.)

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
!!Parent page

We are trying to [[assess the prospects for the shrinking-neighbourhoods game|Is the shrinking neighbourhoods game likely to work for our purposes?]].

!Introduction

As observed at the end of [[this page|How easy is it to lift a 2-basic set to a 1-basic set?]], if we can find a lift that simultaneously converts all basic sets into basic $$i$$-sets for some fixed $$i$$ (that is, basic sets of the form $$\{x\in X:x_i\in\Delta_i\}$$ for that particular $$i$$), then we have simultaneously converted //all// subsets of $$X$$ into basic sets, so we have not distinguished between sets of low circuit complexity and arbitrary sets.

That raises a serious-looking worry. Martin shows that every Borel game can be lifted to a game that is closed and open. He also shows that every closed game can be lifted to a game that is decided after the first two moves. It is also easy to check that a lift of a game that is decided after the first two moves is still decided after the first two moves, and the lift of a closed game is closed. Therefore, by composing lifts one can prove that any finite set of Borel games can be simultaneously lifted to games that are decided after the first two moves.

But in the finite set-up, if we can take $$X=\{0,1\}^n$$ and can simultaneously lift the $$n$$ coordinate hyperplanes to sets with the property that membership is determined by two specific coordinates, then we have lifted all subsets of $$X$$ to sets with that property. So it looks as though the analogy with Martin's proof has to break somewhere, and break quite badly. Since the analogy was meant to be a source of encouragement for this approach, the necessity of breaking it is worrying.

On the other hand, the argument just given is not completely precise. The purpose of this page is to decide just how damaging it really is. Does it kill off the approach? Or does it just kill off certain ways of interpreting the approach and point us in the right direction?

!Why it really is quite worrying

All along, the aim has been to find a finitary version of Martin's proof. Already the following thoughts have worried me.
#The sizes of Martin's lifts go up by an exponential (that is, he applies the power-set axiom) at each stage of the iteration, whereas there is a doubly exponential upper bound for a lift that does absolutely everything one could ask of it in the finitary case.
#All games are determined in the finitary case, which makes it possible to find lifts that do not correspond to lifts in the infinitary case (unless one uses the axiom of determinacy).
#The lifts that work for closed sets in the infinitary case are very expensive, so their natural finite counterparts look too expensive if we want to iterate them. In fact, they look too expensive even if we just want to do one of them.

Now let us think about why the observation discussed above does not cause equivalent difficulties in the infinitary case. That is, if we look at the set of all infinite 01-sequences, then what is stopping us simultaneously lifting all sets of the form $$E_i\{x:x_i=1\}$$ so that they become sets for which membership is determined by the first two coordinates? (Once we have that, we can if we wish modify the construction very simply and get membership determined by just the second coordinate. Indeed, for single sets this is basically what Martin does.)

The problem is that while we can easily find a sequence $$X_1,X_2,\dots$$ where each term in the sequence is a lift of the one before (and hence, since a composition of lifts is a lift, of all the ones before), and such that the lift of $$E_i$$ in $$X_i$$ is determined by the first two coordinates, we cannot find a limit of that sequence. If we want to lift infinitely many sets all at once, we need to take an inverse limit, and for that to exist we have to ensure that the first few coordinates eventually stabilize".

However, we don't have this difficulty in the finite case. So it is hard to think how we can find an argument that is truly analogous to Martin's argument. What can we do that will stop a long composition of lifts being a lift without also stopping us from being able to prove that a set with polynomial circuit complexity can be lifted to a basic set?

!Ideas for dealing with some of these problems

Many of our problems come down to the fact that in the finitary set-up we can use the fact that finite games are determined. Is it possible to restrict the notion of a lift so as to rule this out? [[AskSomethingMorePrecise|Can we outlaw the use of finite determinacy?]]
!!Parent page

We are trying to decide [[whether there is an efficient lift that simplifies the parity function|Is there an efficient Ramsey lift for the parity function?]].

!Introduction

Consider the following structure $$Y$$. It consists of sequences $$((x_1,\epsilon),\dots,(x_m,\epsilon),(x_{m+1},\eta),\dots,(x_n,\eta))$$ such that $$\epsilon$$ is the parity of $$x_1+\dots+x_m$$ and $$\eta$$ is the parity of $$x_{m+1}+\dots+x_n$$. In other words, the game on $$Y$$ is like the usual game on $$\{0,1\}^n$$ except that on their first moves the players say what the parities of their total contributions will be. The question is whether this is a Ramsey lift?

!Attempted proof that it is not

Consider the following """I-winning""" set $$A$$. Partition the set $$\{m+1,\dots,n\}$$ into non-singleton sets $$X_1,\dots,X_r$$ of odd size. Let $$A$$ be the set of all $$x$$ such that either $$x$$ has even parity or there exists $$j$$ such that the restriction of $$x$$ to $$X_j$$ is not constant.

''Check that this set is """I-winning"""''

When Player II has specified $$m-2$$ coordinates, he has committed himself to his entire sequence (if he wants to have any chance of winning), since he has played at least one coordinate in each $$X_i$$. This allows Player I to determine the parity of the eventual sequence, since it effectively hands the last move to her.

''Check that it does not lift to a """I-winning""" set''

If the two players have to declare the parities of their contributions when they make their first moves, then Player II can ensure that the sum of these parities is odd, and can then continue in such a way that the restrictions of $$x$$ to all the $$X_j$$ are constant.

It consists of all sequences such that either the parity of $$x_1+\dots+x_{n-1}$$ is 1 or $$x_{n-1}\ne x_n$$.

!Conclusion

That worked, and it shows that that lift is not Ramsey.
/***
|''Name''|TiddlyFileImporter|
|''Version''|0.3.8|
|''Author''|Ben Gillies|
|''Type''|plugin|
|''Description''|Upload a TiddlyWiki file to TiddlyWeb, and import the tiddlers.|
!Usage
Upload a TiddlyWiki file to TiddlyWeb, and import the tiddlers.
!Requires
tiddlyweb
tiddlywebplugins.reflector
!Code
***/
//{{{
(function($){ if(!version.extensions.TiddlyFileImporter) { //# ensure that the plugin is only installed once version.extensions.TiddlyFileImporter = { installed: true }; } config.macros.fileImport = { reflectorURI: '/reflector?csrf_token=%0', incorrectTypeError: 'Incorrect File Type. You must upload a TiddlyWiki', uploadLabel: 'Upload', uploadLabelPrompt: 'Import tiddlers from this TiddlyWiki', step1FileText: 'File:', step1PostText: 'In the next screen you will select the tiddlers to import.', step1Title: 'Step 1: Pick a TiddlyWiki to import', step1TypeChooser: 'Import From:', step3Html: ['<input type="hidden" name="markList" />', '<input type="hidden" checked="true" name="chkSync" />', '<input type="hidden" name="chkSave" />', '<input type="hidden" name="txtSaveTiddler" />'].join(), handler: function(place, macroName, params, wikifier, paramString) { var wizard = new Wizard(); wizard.createWizard(place, 'Import a TiddlyWiki'); this.restart(wizard); }, restart: function(wizard) { var me = config.macros.fileImport; wizard.addStep(me.step1Title, ['<input type="hidden" ', 'name="markList" />'].join("")); var markList = wizard.getElement('markList'); var uploadWrapper = document.createElement('div'); markList.parentNode.insertBefore(uploadWrapper, markList); uploadWrapper.setAttribute('refresh', 'macro'); uploadWrapper.getAttribute('macroName', 'fileImport'); var iframeName = 'reflectorImporter' + Math.random().toString(); me.createForm(uploadWrapper, wizard, iframeName);$(uploadWrapper).append('
' + me.step1PostText + '
');
wizard.setValue('serverType', 'tiddlyweb');
wizard.setValue('host', config.defaultCustomFields['server.host']);
wizard.setValue('context', {});
var iframe = $([''].join("")).appendTo(uploadWrapper); var onSubmit = function(ev) { var uploadType =$('select[name=uploadtype]', wizard.formElem).val();
wizard.importType = 'file';
wizard.formElem.submit();
} else {
var csrf_token = config.extensions.tiddlyspace.getCSRFToken();
$.ajax({ url: "%0/reflector?csrf_token=%1".format( config.defaultCustomFields["server.host"], csrf_token), type: "POST", dataType: "text", data: { uri:$("input", ".importFrom", wizard.formElem).val()
},
success: function(data, txtStatus, xhr) {
wizard.POSTResponse = data;
},
error: function(xhr, txtStatus, error) {
displayMessage(["There was an error fetching the ",
'url: ', txtStatus].join(""));
me.restart(wizard);
}
});
return false;
}
};
wizard.setButtons([{
onClick: onSubmit
}]);
$(wizard.formElem).submit(function(ev) { onSubmit(ev); ev.preventDefault(); }); }, createForm: function(place, wizard, iframeName) { var form = wizard.formElem; var me = config.macros.fileImport; form.action = me.reflectorURI.format( config.extensions.tiddlyspace.getCSRFToken()); form.enctype = 'multipart/form-data'; form.encoding = 'multipart/form-data'; form.method = 'POST'; form.target = iframeName; onSelectChange = function(e) { var changeTo =$(this).val();
if (changeTo == "file") {
$(".importFrom").html('%0 <input type="file" name="file" />'. format(me.step1FileText)); } else {$(".importFrom").html('URL: <input type="text" name="uri" />'
+ ' Do you want inclusion instead?');
}
};
$(place).append('%0'.format(me.step1TypeChooser)). append($(['<select name="uploadtype"><option value="file" selected="selected">file',
'<option value="uri">url</select>'].join("")).change(onSelectChange)).
append('
%0<input type="file" name="file" />
'.
format(me.step1FileText));
},

var me = config.macros.fileImport;
me.importTiddlers.apply(this, [place, wizard, iframe]);
};
}
};
},

importTiddlers: function(place, wizard, iframe) {
var tmpStore = new TiddlyWiki();
var POSTedWiki = "";
if (wizard.importType == "file") {
try {
POSTedWiki= iframe.contentWindow
.document.documentElement.innerHTML;
} catch(e) {
displayMessage(config.macros.fileImport.incorrectTypeError);
config.macros.fileImport.restart(wizard);
return;
}
// now we are done, so remove the iframe
(iframe).remove(); } else { POSTedWiki = wizard.POSTResponse; } tmpStore.importTiddlyWiki(POSTedWiki); var newTiddlers = tmpStore.getTiddlers(); var workspace = config.defaultCustomFields['server.workspace']; var context = { status: true, statusText: 'OK', httpStatus: 200, adaptor: wizard.getValue('adaptor'), tiddlers: newTiddlers }; context.adaptor.store = tmpStore; wizard.setValue('context', context); wizard.setValue('workspace', workspace); wizard.setValue('inFileImport', true); config.macros.importTiddlers.onGetTiddlerList(context, wizard); } }; var _onGetTiddler = config.macros.importTiddlers.onGetTiddler; config.macros.importTiddlers.onGetTiddler = function(context, wizard) { if (wizard.getValue('inFileImport')) { var me = config.macros.importTiddlers; if(!context.status) displayMessage("Error in importTiddlers.onGetTiddler: " + context.statusText); var tiddler = context.tiddler; var fields = tiddler.fields; merge(fields, config.defaultCustomFields); fields["server.workspace"] = wizard.getValue('workspace'); delete fields['server.permissions']; delete fields['server.bag']; fields['server.page.revision'] = 'false'; delete fields['server.recipe']; fields.changecount = 1; store.suspendNotifications(); store.saveTiddler(tiddler.title, tiddler.title, tiddler.text, tiddler.modifier, tiddler.modified, tiddler.tags, tiddler.fields, false, tiddler.created); store.resumeNotifications(); var remainingImports = wizard.getValue("remainingImports")-1; wizard.setValue("remainingImports",remainingImports); if(remainingImports === 0) { if(context.isSynchronous) { store.notifyAll(); refreshDisplay(); } wizard.setButtons([ {caption: me.doneLabel, tooltip: me.donePrompt, onClick: me.onClose} ],me.statusDoneImport); autoSaveChanges(); } } else { _onGetTiddler.apply(this, arguments); } }; var _onCancel = config.macros.importTiddlers.onCancel; config.macros.importTiddlers.onCancel = function(e) { var wizard = new Wizard(this); if (!wizard.getValue('inFileImport')) { return _onCancel.apply(this, arguments); } var place = wizard.clear(); config.macros.fileImport.restart(wizard); return false; }; var _step3Html = config.macros.importTiddlers.step3Html; var _onGetTiddlerList = config.macros.importTiddlers.onGetTiddlerList; config.macros.importTiddlers.onGetTiddlerList = function(context, wizard) { var fileImport = config.macros.fileImport; var importTiddlers = config.macros.importTiddlers; if (wizard.getValue('inFileImport')) { importTiddlers.step3Html = fileImport.step3Html; } else { importTiddlers.step3Html = _step3Html; } _onGetTiddlerList.apply(this, arguments); }; })(jQuery); //}}} /*{{{*/ .headerForeground { position: relative; padding: 2em 0em 1em 0em; float: right; top: 0; margin-right: 5.3em; background-color: [[ColorPalette::PrimaryMid]]; text-align: right; } .header { width: 100%; /* for ie */ } .clearFloat { clear: both; } #contentWrapper { position: relative; padding-top: 1px; top: -1px; } .header { position: relative; background-color: [[ColorPalette::PrimaryMid]]; } .siteTitle { clear: both; display: block; } #sidebarSearch { padding: 0.8em 1em 1em; width: 10.5em; margin: 0.6em 0.6em; float: right; position: relative; } #sidebarSearch .txtOptionInput { width: 100%; margin-top: 5px; } #sidebarSearch .searchButton { padding: 0.2em; color: [[ColorPalette::Background]]; } /*}}}*/ !!Parent page We are trying to [[find a finitary analogue of Martin's theorem|What might a finitary analogue of Martin's theorem look like?]] !Introduction Given a subset $$A\subset\{0,1\}^n$$, define a game by letting the two players choose alternately the bits $$x_1,x_2,\dots,x_n$$ of a sequence $$x$$. If $$x\in A$$ then Player I wins and otherwise Player II wins. This game is determined, whatever the set $$A$$ might be. However, there are two questions we can ask about this determinacy. #If $$A$$ has low circuit complexity, does that allow us to show that one player has not just any old winning strategy but a winning strategy that is "simple" in some way? #If $$A$$ has low circuit complexity, can we prove that the game is determined by using a smaller lifted game than would be needed for a general payoff set? I will discuss these questions in turn. However, since they are separate questions and they both require a certain amount of discussion, it seems appropriate to discuss them in separate subpages. Are games with low-complexity payoff sets "simply" determined? [[LookForSomethingMoreSpecific|Are games with low-complexity payoff sets "simply" determined?]] Can games with low-complexity payoff sets be lifted to not much larger games with payoff sets that are closed and open? [[LookForSomethingMoreSpecific|Can games with low-complexity payoff sets be lifted to not much larger games with payoff sets that are closed and open?]] !!Parent page We are trying to [[draw an analogy between strategic subtrees of trees and some kind of substructure of a complexity structure|What two classes of sets could serve as a "symmetric analogue" of the classes of strategic subtrees for Player I and Player II?]]. !Introduction A tree structure on $$\{0,1\}^n$$ is a tree with the points of $$\{0,1\}^n$$ as its leaves. We can think of it as the set $$\{0,1\}^n$$ together with all its subsets of the form $$\{x:x_1=\epsilon_1,\dots,x_k=\epsilon_k\}$$. We can also think of it as $$\{0,1\}^n$$ with a metric where the distance between $$x$$ and $$y$$ is $$n-k$$, where $$k$$ is maximal such that $$x_i=y_i$$ for every $$i\leq k$$. A much more natural metric from a complexity point of view is the Hamming metric: that is, the distance between $$x$$ and $$y$$ is the number of $$i$$ such that $$x_i\ne y_i$$. Maybe one way of phrasing the question I want to ask is this: given a tree with $$n$$ levels, can we find a metric-preserving bijection between its leaves and a complexity structure $$X$$ with the Hamming metric? !Attempted construction I think the answer ought to be yes. I want to achieve that by mapping each leaf to the sequence of vertices in the path from the root to that leaf (not including the root itself). Does that work? The number of points where two sequences differ is precisely $$n-k$$, where $$k$$ is maximal such that the two sequences agree up to that point. We can regard this as a complexity structure by taking the alphabet to be the set of all vertices of the tree, though it is more natural to think of it as a subset of $$V_1\times\dots\times V_n$$, where $$V_i$$ is the set of vertices at level $$i$$. That was easy enough. So let's [[return to the parent page|What two classes of sets could serve as a "symmetric analogue" of the classes of strategic subtrees for Player I and Player II?]].  !!Parent page We asked [[why nothing seems to work|Why does nothing seem to work?]] and introduced the natural proofs barrier as a surprisingly precise answer to that question. !Introduction Not surprisingly, many people have thought about this question. There are two ways one can try to get round the natural proofs barrier. One is to look for a simplicity property that is very strange and complicated -- sufficiently so that it can tell the difference between pseudorandom functions and genuinely random functions -- and the other is to look for a property that applies to almost all functions. Let me briefly mention a difficulty with the second. I associate the following simple observation with Razborov, but I don't know for sure that he was the first to make it. !An objection to simplicity properties that apply to almost all functions Suppose we have a simplicity property that applies to 99% of functions. Now let $$f$$ be a function in NP that we are hoping to show is not simple, and let $$g$$ be a Boolean function chosen uniformly at random. Then the mod-2 sum $$h=f\oplus g$$ is also a Boolean function chosen uniformly at random. It follows that with probability at least 99%, both $$g$$ and $$h$$ are simple. Therefore, this simplicity property has the following undesirable feature: it is possible for functions $$g$$ and $$h$$ to be simple, but for the function $$g\oplus h$$, which is built out of $$g$$ and $$h$$ in a very simple way, not to be simple. !!An attempt to wriggle out of that difficulty How strong an objection is this? One might try arguing that if simplicity is a matter of degree, then it isn't surprising that if we choose some cutoff for saying when a function is simple, then the simple functions are not closed under simple Boolean operations. However, we can't get very far with that argument. Suppose we have a simplicity parameter $$S$$. What we would like is for $$S(f)$$ to be small when $$f$$ is a function of polynomial circuit complexity and large when $$f$$ is some specified function in NP. If we define a function $$f$$ to be simple if $$S(f)\leq t$$ for some appropriate bound $$t$$, then although the simple functions won't be closed under $$\oplus$$, we would at least expect to be able to show that if $$f$$ and $$g$$ are simple, then $$f\oplus g$$ is not hugely complicated: that is we would expect to be able to show that $$S(f\oplus g)$$ is not that much larger than $$t$$. That is, writing $$\Sigma$$ for the class of simple functions, we would expect to be able to show not only that our target function does not belong to $$\Sigma$$, but also that it does not belong to $$\Sigma\oplus\Sigma$$ (by which I mean the set of all functions $$g\oplus h$$ such that $$g,h\in\Sigma$$). However, if $$\Sigma$$ contains 99% of all functions, then we will not be able to show that. !!A second attempt to wriggle out of that difficulty Perhaps one should not get too hung up on the notion of "simplicity". Another idea is to focus on what one might call "closeness to the target". Suppose, for example, that the NP set we would like to show has large circuit complexity is the set of all graphs on $$r$$ vertices (where $$n=\binom r2$$) that contain a clique of size $$s$$. We might try to find a measure of progress that told us, given a function $$f$$, "how much progress" $$f$$ had made towards detecting $$r$$-cliques. Perhaps we could show that functions with low circuit complexity would have made almost no progress. And perhaps it would be reasonable to expect that a random function had made almost no progress either. Of course, we would have to accept that a mod-2 sum of two functions that had made almost no progress could actually be the clique function itself, but that is not necessarily a disaster. Unfortunately, this "backwards" approach runs into a sort of "backwards natural proofs barrier". Let me stick with the cliques example. Then if we are thinking of our distinguishing property as a measure of progress towards detecting $$r$$-cliques, it would seem that a minimal requirement of such a property would be that if $$f$$ is a Boolean function, and if, given the value of $$f$$, you can determine with a polynomial-sized circuit whether your graph contains an $$r$$-clique, then $$f$$ has not made "almost no progress" towards computing the clique function. Let $$c$$ be the clique function, let $$g$$ be a function of polynomial circuit complexity, and let $$f=c\oplus g$$. Then if we are told the value of $$f$$, we can compute the value of the clique function by computing $$g$$ (since $$c=f\oplus g$$). So the requirement discussed in the previous paragraph would demand that $$c\oplus g$$ is regarded as "making progress towards $$c$$" for every function $$g$$ of polynomial circuit complexity. But now we run into the natural proofs difficulty. If we take $$g$$ to be a random low-complexity function (for instance, given by [[this model|A model of random functions of circuit complexity at most m]]), then $$c\oplus g$$ looks very much like a random function. Therefore, any "measure of progress" property that is too simple to distinguish between pseudorandom functions and random functions will not be able to tell the difference between a random function of the form $$c\oplus g$$ with $$g$$ of low complexity and a purely random function. Since all the functions $$c\oplus g$$ with $$g$$ of low complexity should satisfy the "close to $$c$$" property, almost all functions will have to satsify that property. But that defeats the whole point of the exercise, since the reason we were considering "closeness to $$c$$" was that we wanted very //few// functions to be close to $$c$$. !!Is there any hope of wriggling out of the difficulty? I do not have much more to say about this. I myself plan to concentrate on finding a simplicity property that is "strange" rather than one that is "large". However, there is at least one serious line of attack on the P versus NP problem, Ketan Mulmuley's [[geometric complexity theory|http://en.wikipedia.org/wiki/Geometric_complexity_theory]], that is thought to avoid the natural proofs barrier by (implicitly) formulating a complexity property that does not apply to many functions. I think the reason for that is very roughly that the property requires the functions to have many symmetries that are not enjoyed by a typical function. The viability of Mulmuley's programme has been much discussed, and I think there is no consensus about whether it might fall victim to some variant of the natural proofs barrier, or perhaps some other barrier. For some interesting discussion about Mulmuley's programme and the natural proofs barrier, see [[this question at the computer science stack exchange|http://cstheory.stackexchange.com/questions/170/how-does-the-mulmuley-sohoni-geometric-approach-to-producing-lower-bounds-avoid]] and Section 6 of [[this exposition by Ken Regan|http://www.cse.buffalo.edu/faculty/regan/papers/pdf/Reg02MSFD.pdf]]. Another remark worth making is that some celebrated recent work of Ryan Williams establishes a separation of two complexity classes in a way that gets round the natural-proofs barrier. Unfortunately, I don't understand enough about this to be able to write about it. In particular, I don't know whether it is (explicitly or implicitly) defining a "large" simplicity property or a "strange" one.
 I hope that the discussion above is sufficient motivation for the next question I would like to consider: what could a "strange" simplicity property conceivably be like? [[LookForSomethingMoreSpecific|What could a "strange" simplicity property conceivably be like?]] <!DOCTYPE html>   <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1"> <title>Reply</title> <link rel="stylesheet" href="//tiddlyspace.com/bags/benspa_public/tiddlers/bootvelcro.css">
 <form action="#" class="modal">
 <button id="help">help</button>

 Found something interesting? Write about it in your own space. Find out more

Reply

 <fieldset id="postForm" class="modal-body"> Title <input type="text" name="title">  <input type="hidden" name="url"> Post <textarea name="text" rows="8"></textarea>  Tags <input type="text" name="tags" value="">  </fieldset>
  <input type="checkbox" name="private" val="private"> keep private  <input type="submit" class="btn primary btn-large" value="Done"> <input type="button" class="btn btn-large closeBtn" value="Cancel">
 </form>
      <!DOCTYPE html>   <meta http-equiv="Content-Type" content="text/html;charset=utf-8"> <title>Account</title> <link href="/bags/common/tiddlers/profile.css" type='text/css' rel='stylesheet' > <link href="/bags/common/tiddlers/admin.css" type='text/css' rel='stylesheet' > <link href="/bags/common/tiddlers/jquery-ui.custom.css" type='text/css' rel='stylesheet' >

 home

User Icon

  <form id="upload" method="POST" enctype="multipart/form-data"> <input type="hidden" name="title" value="SiteIcon" /> <input type="hidden" name="tags" value="excludeLists"> <input type="hidden" name="csrf_token" class="csrf" /> <input type="file" name="file" accept="image/*" /> <input type="submit" value="upload" /> </form>
Drop file here

Find Space
 <form class="spaceSearch"> <input class="inputBox" type="text" placeholder="find space" /> What is a space? <button>view all</button> </form>
 You are a member of the following spaces:

Create New Space
 <form class="ts-spaces"> <input class="inputBox" type="text" name="spacename" placeholder="space name">.tiddlyspace.com <input type="submit" value="Create Space" /> </form>

Change Password
 <form class="ts-password"> <input class="inputBox" placeholder="existing password" type="password" name="password"> <input class="inputBox" placeholder="new password" type="password" name="new_password"> <input class="inputBox" placeholder="new password" type="password" name="new_password_confirm"> <input type="submit" value="Change password"> </form>
OpenID

Why OpenID?

 Use just one username and password across hundreds of OpenID-enabled sites.
 It's an open standard.
 learn more

 <form class="ts-openid" target="_top">
 Add an openid:
 <input class="inputBox" type="text" name="openid" placeholder="your openid" /> <input type="submit" value="Register" /> What is an open id? </form>

                !Upload an icon <<tiddler spaceIcon>> !Describe your space If you haven't already done so, you should provide a brief decscription of yourself and what you're using this space for. To do this, just edit the [[SiteInfo]] tiddler (keeping the title the same of course). !Change the title <<tiddler spaceTitle>> !Change the theme <<tiddler colorScheme>> !Change the menu If you'd like to change the menu items along the top, you can edit the [[MainMenu]] tiddler. !Change the default tiddlers <<tiddler setDefaultTiddlers>> !More Advanced customisations If you know HTML and CSS, you can edit some or all of the following tiddlers to customise your space further: * PageTemplate * EditTemplate * ViewTemplate * StyleSheet !Introduction Let $$X=\{0,1\}^n$$ and suppose that we are trying to find a lift $$\pi:Y\to X$$. I have a hunch that there must be some limit to how large the alphabet for $$Y$$ can possibly need to be before the pigeonhole principle tells us that all we are doing is repeating information that we already have. Here I want to try to make this hunch precise. If I manage to do so, then I want to find out what bound results. !What does it mean to say that two elements of the alphabet are effectively the same? The definition I had in mind was this. For convenience I'll take $$Y$$ to be a subset of $$\Gamma_1\times\dots\times\Gamma_n$$ and I'll consider two elements $$\gamma$$ and $$\gamma'$$ of $$\Gamma_1$$. I would want to call them equivalent if $$\pi(y)=\pi(y')$$ whenever $$y$$ is a sequence with first coordinate $$\gamma$$ and $$y'$$ is the result of replacing that $$\gamma$$ by $$\gamma'$$. However, I now see that that definition is flawed, because we have to take into account whether it is actually //possible// to replace $$\gamma$$ by $$\gamma'$$ and still obtain an element of $$Y$$. In general it won't be. !Is there an example that shows that there are infinitely many "genuinely distinct" lifts? I wondered about the following idea. Let $$n=2$$ and let $$\Gamma_1=\Gamma_2=\{0,1,2,\dots,n\}$$. Let $$Y$$ be the set of all sequences $$(r,s)$$ such that $$r=s$$ or $$r=s+1$$, and let $$\pi$$ take $$(r,s)$$ to $$\epsilon_1,\epsilon_2)$$, where $$\epsilon_1=0$$ if and only if $$r=0$$ and $$\epsilon_2=0$$ if and only if $$s=0$$. According to the above definition, all such lifts will be distinct. !What would be a good definition of "essentially the same"? I think the best hope of answering this question is to be as category-theoretic as possible. That is, I'd like to declare two lifts to be essentially the same if I can find suitable maps between them. However, I can't afford to insist that the two maps invert each other. Maybe what I want is that if I've got $$\pi:Y\to X$$ and $$\pi':Y'\to X$$, then I can find $$\phi:Y\to Y'$$ such that $$\pi=\pi'\circ\phi$$ and I can also find $$\psi:Y'\to Y$$ such that $$\pi'=\pi\circ\psi$$. If I had that, then would it follow that $$Y$$ has the Ramsey property if and only if $$Y'$$ has it? Let me try to prove that it would. Let $$W$$ be a winning subset of $$Y$$ and suppose that $$\pi':Y'\to X$$ has the Ramsey property. I would like to argue that $$\psi^{-1}(W)$$ is a winning set for $$Y'$$, but can I? Let $$\sigma$$ be a winning strategy for $$W$$. Then I would need to find a winning strategy for $$\psi^{-1}(W)$$. I see no reason for it to exist. Hang on, let's suppose that $$W$$ is winning for Player I. If $$\psi^{-1}(W)$$ is not winning for Player I, then $$\psi^{-1}(W)^c$$ is winning for Player II. I don't seem to be getting anywhere.  !!Parent page We want to know [[whether all non-trivial Ramsey lifts use large alphabets|Must all non-trivial Ramsey lifts use large alphabets?]]. !Introduction Let $$X\subset\Gamma^2$$ and $$Y\subset\Theta^2$$, and let $$\pi:Y\to X$$ be given by the formula $$\pi(y_1,y_2)=(\phi(y_1),\phi(y_2))$$. Suppose that $$\pi:Y\to X$$ is a non-trivial Ramsey lift. Is it possible that $$|\Theta|\leq C|\Gamma|$$ for some constant $$C$$ that is independent of $$|\Gamma|$$? I need to be a bit clearer about quantifiers here. What I am asking is whether there exists a constant $$C$$ such that for every $$X$$ as above there exists a non-trivial Ramsey lift $$\pi:Y\to X$$ with $$|\Theta|\leq C|\Gamma|$$. If the answer to that is no, then I would be interested if "for every $$X$$" could be replaced by "for arbitrarily large $$X$$". !What is a Ramsey lift in this case? A minimal """I-winning""" subset of $$X$$ is a set of the form $$X_\gamma=\{x\in X:x_1=\gamma\}$$. A """II-winning set""" is a set $$W$$ such that for every $$\gamma\in\Gamma$$ such that there exists $$x\in X$$ with $$x_1=\gamma$$, there exists $$w\in W$$ such that $$w_1=\gamma$$. If we think of $$X$$ as a bipartite graph, this is saying that every non-isolated vertex in the first copy of $$\Gamma$$ is incident with an edge in $$W$$. So a Ramsey lift $$\pi:Y\to X$$ must take the "full stars" in $$Y$$ that form """I-winning""" sets and map them to "full stars" in $$X$$. And it must take the "functions" that form """II-winning""" sets and map them to "functions" in $$X$$. Let's see if we can pin this down slightly more. Let us take the star $$\{y\in Y:y_1=\theta\}$$. This maps to the set $$\{x\in X:x_1=\phi(\theta), x_2\in\phi(N(\theta))\}$$, where $$N(\theta)=\{\theta':(\theta,\theta')\in Y\}$$ is the neighbourhood of $$\theta$$ in $$Y$$. Therefore, we require $$N(\phi(\theta))\subset\phi(N(\theta))$$ for every $$\theta\in\Theta$$ in order for """I-winning""" sets to map to """I-winning""" sets. How about """II-winning""" sets? Here we need the following. Let $$\Theta_1\subset\Theta$$ be the set of all $$\theta$$ such that there exists $$\theta'$$ with $$(\theta,\theta')\in Y$$ and let $$f:\Theta_1\to\Theta$$ be an arbitrary function with the property that $$(\theta,f(\theta))\in Y$$ for every $$\theta\in\Theta_1$$. Let $$\Gamma_1\subset\Gamma$$ be the set of all $$\gamma$$ such that there exists $$\gamma'$$ with $$(\gamma,\gamma')\in X$$. It seems that for """II-winning""" sets to be preserved, all we need is for $$\Gamma_1$$ to be contained in $$\phi(\Theta_1)$$. !What is a trivial lift in this case? Let us define $$\Gamma_2\subset\Gamma$$ to be the set of all $$\gamma$$ such that there exists $$\gamma'$$ with $$(\gamma',\gamma)\in X$$, and let $$\Theta_2\subset\Theta$$ be defined similarly. Then we need the following properties of the map $$\phi$$. #$$\Gamma_1\subset\phi(\Theta_1)$$. #$$\Gamma_2\subset\phi(\Theta_2)$$. #For every point $$(\gamma,\gamma')$$ in $$X$$ and every $$\theta$$ such that $$\phi(\theta)=\gamma$$ there exists $$\theta'$$ such that $$(\theta,\theta')\in Y$$ and $$\phi(\theta')=\gamma'$$. #For every point $$(\gamma,\gamma')$$ in $$X$$ and every $$\theta'$$ such that $$\phi(\theta')=\gamma'$$ there exists $$\theta$$ such that $$(\theta,\theta')\in Y$$ and $$\phi(\theta)=\gamma$$. We can rephrase condition 3 as follows. For every point $$\gamma\in X$$ and every $$\theta$$ such that $$\phi(\theta)=\gamma$$, $$N(\gamma)\subset\phi(N(\theta))$$. In the presence of condition 1, this is essentially the condition that """I-winning""" sets map to """I-winning""" sets. This is quite interesting. If I'm not much mistaken, the triviality conditions 1 and 3 are precisely the same as the conditions for the lift to be Ramsey. Since the motivation for the triviality definition was that it gave a circumstance where it was easy to prove that a lift was Ramsey, it doesn't seem particularly interesting to worry about conditions 2 and 4 (which are saying that the map would still be Ramsey if Player II went first). Or does it? The proof that a trivial lift can't turn a non-basic set into a basic set requires both directions of triviality (since the result is false for a general Ramsey lift). So perhaps we should think about whether it is easy to construct a lift that is Ramsey when Player I starts but not when Player II starts. !How easy is it to construct a non-trivial Ramsey lift? Suppose we have conditions 1 and 3, and $$\gamma'\in\Gamma_2$$. Then there exists $$\gamma$$ such that $$(\gamma,\gamma')\in X$$ (by definition of $$\Gamma_2$$). Next, there exists $$\theta$$ such that $$\phi(\theta)=\gamma$$, by condition 1. But then, by condition 3, there exists $$\theta'$$ such that $$\phi(\theta')=\gamma'$$ and $$(\theta,\theta')\in Y$$. It follows that $$\gamma'\in\phi(\Theta_2)$$. Thus, conditions 1 and 3 imply condition 2. The only hope, therefore, of constructing a non-trivial Ramsey lift is to construct a lift that satisfies conditions 1-3 but violates condition 4. !An attempt to do this with a minimal approach I'd like to do something like building a very simple lift $$\pi:Y\to X$$ and then modifying it as little as possible to make sure that condition 4 does not hold. I'll start with the simplest possibility of all, which is very unlikely to work. (I'm playing a game of """GuessAndAdjust""" here.) I'll take $$Y_0=X$$ and let $$\pi$$ be the identity map. Now choose a point $$(\gamma,\gamma')\in X$$ and let $$Y=Y_0\setminus\{(\gamma,\gamma')$$. Does this work? No it doesn't, because although removing $$(\gamma,\gamma')$$ from $$Y$$ ensures that condition 4 does not hold, it also ensures that condition 3 does not hold. So we need to preserve condition 3. Let us try to do this as follows. Again let us fix an element $$(\gamma,\gamma')$$ of $$X$$. This time, let us duplicate $$\gamma'$$, so that we have elements $$\gamma_1'$$ and $$\gamma_2'$$. By that I mean that $$\Theta$$ is obtained from $$\Gamma$$ by removing $$\gamma'$$ and adding in $$\gamma_1'$$ and $$\gamma_2'$$, and $$\phi(\gamma_i')=\gamma'$$ for $$i=1,2$$. Let $$Y_0=\pi^{-1}(X)$$. Now in order to spoil condition 4, let us remove from $$Y_0$$ the pair $$(\gamma,\gamma_2')$$. This does indeed stop condition 4 holding, since we can take the point $$(\gamma,\gamma')\in X$$ and the point $$\gamma_2'\in\Theta$$. What about condition 3? Well, it obviously holds for $$Y_0$$, so the only way it could conceivably be violated is by the pair $$(\gamma,\gamma')\in X$$ and the point $$\gamma\in\Theta$$. But it is not violated by this choice, since we can choose $$\gamma_1'$$ and we have $$(\gamma,\gamma_1')\in Y$$ and $$\phi(\gamma_1')=\gamma'$$. So it turns out to be easy to to construct a non-trivial lift -- we just have to add 1 to the size of the alphabet. [[Return to parent page|Must all non-trivial Ramsey lifts use large alphabets?]]  !!Parent page We are trying [[to find a useful formal complexity measure|Is there a useful formal complexity measure?]]. We have noted that it would help if formula complexity was in some sense comparable to circuit complexity. !Introduction An approach using formal complexity measures would have a chance of giving us non-trivial lower bounds on circuit complexity if such bounds followed from lower bounds on formula complexity. Unfortunately, there are good reasons to believe that this is not the case. A rough argument that convinces me is that there is a probability distribution on functions of low circuit complexity such that there is no reason to imagine that a random function chosen from this distribution would have anything other than huge formula complexity. I may provide more details about this rough argument at some point. For now, I ask you to take it on trust that even an exponential lower bound for formula complexity is unlikely to imply even a superlinear lower bound for circuit complexity, and that a suitably "generic" function of circuit complexity at most $$100n$$, say, ought to be a counterexample. !What next? This may already be enough to convince you that we shouldn't be looking for a numerical measure of simplicity. If so, you may want to backtrack as far as the page [[Is there a useful definition of simplicity?]] Alternatively, you could go back just to [[the parent page of this page|Is there a useful formal complexity measure?]] and read about a different objection to formal complexity measures.  /*** |''Name''|TiddlySpaceConfig| |''Version''|0.7.7| |''Description''|TiddlySpace configuration| |''Status''|stable| |''Source''|http://github.com/TiddlySpace/tiddlyspace/raw/master/src/plugins/TiddlySpaceConfig.js| |''CoreVersion''|2.6.1| |''Requires''|TiddlyWebConfig ServerSideSavingPlugin TiddlyFileImporter| !Code ***/ //{{{ (function($) {

var tweb = config.extensions.tiddlyweb;

var recipe = config.defaultCustomFields["server.workspace"].split("recipes/")[1];
var currentSpace; // assigned later

var disabledTabs = [];

var coreBags = ["system", "tiddlyspace"];
var systemSpaces = ["plugins", "info", "images", "theme"];
systemSpaces = $.map(systemSpaces, function(item, i) { return "system-%0_public".format(item); }); // hijack search macro to add custom attributes for mobile devices var _search = config.macros.search.handler; config.macros.search.handler = function(place, macroName, params) { _search.apply(this, arguments);$(".searchField:input", place).
attr({ autocapitalize: "off", autocorrect: "off" });
};

// arg is either a container name or a tiddler object
// if fuzzy is truthy, space may be inferred from workspace (for new tiddlers)
// returns space object or false
var determineSpace = function(arg, fuzzy) {
if(typeof arg == "string") { // container name
var space = split(arg, "_", "r");
return ["public", "private"].contains(space.type) ? space : false;
} else if(arg) { // tiddler
var container = determineContainer(arg, fuzzy);
return container ? determineSpace(container.name, fuzzy) : false;
} else {
return false;
}
};

// if fuzzy is truthy, container may be inferred from workspace for new tiddlers
// returns container object or false
var determineContainer = function(tiddler, fuzzy) { // TODO: expose?
var bag = tiddler.fields["server.bag"];
var recipe = tiddler.fields["server.recipe"]; // XXX: unused/irrelevant/redundant!?
if(bag) {
return { type: "bag", name: bag };
} else if(recipe) {
return { type: "recipe", name: recipe };
} else if(fuzzy) { // new tiddler
var workspace = tiddler.fields["server.workspace"];
if(workspace) {
var container = split(workspace, "/", "l");
return ["bags", "recipes"].contains(container.type) ? container : false;
} else {
return false;
}
} else {
return false;
}
};

// hijack removeTiddlerCallback to restore tiddler from recipe cascade -- TODO: move into TiddlyWebWiki?
var sssp = config.extensions.ServerSideSavingPlugin;
var _removeTiddlerCallback = sssp.removeTiddlerCallback;
sssp.removeTiddlerCallback = function(context, userParams) {
var title = context.tiddler.title;
var recipe = context.tiddler.fields["server.recipe"];
_removeTiddlerCallback.apply(this, arguments);
if(recipe) {
context.workspace = "recipes/" + recipe;
var callback = function(context, userParams) {
if(context.status) {
var dirty = store.isDirty();
store.saveTiddler(context.tiddler).clearChangeCount();
store.setDirty(dirty);
} else {
store.notify(title, true);
}
};
}
};

// splits a string once using delimiter
// mode "l" splits at the first, "r" at the last occurrence
// returns an object with members type and name
var split = function(str, sep, mode) {
mode = mode == "r" ? "pop" : "shift"; // TODO: use +/-1 instead of "l"/"r"?
var arr = str.split(sep);
var type = arr.length > 1 ? arr[mode]() : null;
return { type: type, name: arr.join(sep) };
};

var plugin = config.extensions.tiddlyspace = {
currentSpace: determineSpace(recipe),
coreBags: coreBags.concat(systemSpaces),

determineSpace: determineSpace,
isValidSpaceName: function(name) {
return name.match(/^[a-z][0-9a-z\-]*[0-9a-z]$/) ? true : false; }, getCurrentBag: function(type) { return "%0_%1".format(currentSpace, type); }, getCurrentWorkspace: function(type) { return "bags/" + this.getCurrentBag(type); }, // returns the URL for a space's avatar (SiteIcon) based on a server_host // object and an optional space name // optional nocors argument prevents cross-domain URLs from being generated getAvatar: function(host, space, nocors) { if(space && typeof space != "string") { // backwards compatibility -- XXX: deprecated space = space.name; } var subdomain = nocors ? currentSpace : space; host = host ? this.getHost(host, subdomain) : ""; var bag = space ? "%0_public".format(space) : "tiddlyspace"; return "%0/bags/%1/tiddlers/SiteIcon".format(host, bag); }, // returns the URL based on a server_host object (scheme, host, port) and an // optional subdomain getHost: function(host, subdomain) { if(host === undefined) { // offline tweb.status.server_host = {}; // prevents exceptions further down the stack -- XXX: hacky workaround, breaks encapsulation return null; } subdomain = subdomain ? subdomain + "." : ""; var url = "%0://%1%2".format(host.scheme, subdomain, host.host); var port = host.port; if(port && !["80", "443"].contains(port)) { url += ":" + port; } return url; }, disableTab: function(tabTiddler) { if(typeof(tabTiddler) == "string") { disabledTabs.push(tabTiddler); } else { for(var i = 0; i < tabTiddler.length; i++) { plugin.disableTab(tabTiddler[i]); } } }, checkSyncStatus: function(tiddler) { if(tiddler) { var title = typeof(tiddler) === "string" ? tiddler : tiddler.title; var el = story.getTiddler(title) || false; if(el) { refreshElements(el); } } }, isDisabledTab: function(tabTitle) { var match = new RegExp("(?:\$\\[([^\$]+)\\]\\])", "mg").exec(tabTitle); var tabIdentifier = match ? match[1] : tabTitle; return disabledTabs.contains(tabIdentifier); }, getCSRFToken: window.getCSRFToken || null // this may not have been processed yet }; currentSpace = plugin.currentSpace.name; tweb.serverPrefix = tweb.host.split("/")[3] || ""; // XXX: assumes root handler tweb.getStatus(function(status) { var url = plugin.getHost(status.server_host); tweb.status.server_host.url = url; config.messages.tsVersion = status.version; }); if(window.location.protocol == "file:") { // enable AutoSave by default config.options.chkAutoSave = config.options.chkAutoSave === undefined ? true : config.options.chkAutoSave; } else { // set global read-only mode based on membership heuristics var indicator = store.getTiddler("SiteTitle") || tiddler; readOnly = !(recipe.split("_").pop() == "private" || tweb.hasPermission("write", indicator)); // replace TiddlyWiki's ImportTiddlers due to cross-domain restrictions if(config.macros.fileImport) {$.extend(config.macros.importTiddlers, config.macros.fileImport);
}
}

// hijack saveChanges to ensure SystemSettings is private by default
var _saveChanges = saveChanges;
saveChanges = function(onlyIfDirty, tiddlers) {
if(tiddlers && tiddlers.length == 1 &&
tiddlers[0] && tiddlers[0].title == "SystemSettings") {
var fields = tiddlers[0].fields;
delete fields["server.recipe"];
fields["server.bag"] = plugin.getCurrentBag("private");
fields["server.workspace"] = plugin.getCurrentWorkspace("private");
}
return _saveChanges.apply(this, arguments);
};

// ensure backstage is always initialized
// required to circumvent TiddlyWiki's read-only based handling
config.macros.backstageInit = {
init: function() {
showBackstage = true;
}
};

// disable evaluated macro parameters for security reasons
config.evaluateMacroParameters = "none";
var _parseParams = String.prototype.parseParams;
String.prototype.parseParams = function(defaultName, defaultValue, allowEval,
if(config.evaluateMacroParameters == "none") {
arguments[2] = false;
}
return _parseParams.apply(this, arguments);
};

var _tabsMacro = config.macros.tabs.handler;
config.macros.tabs.handler = function(place, macroName, params) {
var newParams = [params[0]]; // keep cookie name
for(var i = 1; i < params.length; i += 3) {
var tabTitle = params[i + 2];
if(!plugin.isDisabledTab(tabTitle)){
newParams = newParams.concat(params[i], params[i + 1], tabTitle);
}
}
_tabsMacro.apply(this, [place, macroName, newParams]);
};

// disable ControlView for XHRs by default
$.ajaxSetup({ beforeSend: function(xhr) { xhr.setRequestHeader("X-ControlView", "false"); } }); // TiddlyWeb adaptor currently still uses httpReq, which needs extra magic -- XXX: obsolete this! var _httpReq = httpReq; httpReq = function(type, url, callback, params, headers, data, contentType, username, password, allowCache) { headers = headers || {}; headers["X-ControlView"] = "false"; _httpReq.apply(this, arguments); }; // register style sheet for backstage separately (important) store.addNotification("StyleSheetBackstage", refreshStyles); // option for default privacy setting config.optionsDesc.chkPrivateMode = "Set your default privacy mode to private"; config.optionsSource.chkPrivateMode = "setting"; config.options.chkPrivateMode = config.options.chkPrivateMode || false; saveSystemSetting("chkPrivateMode", true); config.defaultCustomFields["server.workspace"] = plugin. getCurrentWorkspace(config.options.chkPrivateMode ? "private" : "public"); config.paramifiers.follow = { onstart: function(v) { if(!readOnly) { var bag = "%0_public".format(currentSpace); story.displayTiddler(null, v, DEFAULT_EDIT_TEMPLATE, null, null, "server.bag:%0 server.workspace:bags/%0".format(bag)); story.setTiddlerTag(v, "follow", 1); story.focusTiddler(v, "text"); } } }; var fImport = config.macros.fileImport; if(fImport) { fImport.uploadTo = "Upload to: "; var _createForm = config.macros.fileImport.createForm; config.macros.fileImport.createForm = function(place, wizard, iframeName) { var container =$("
").text(fImport.uploadTo).appendTo(place);
var select = $('<select name="mode" />').appendTo(container)[0];$('<option value="private" selected>private').appendTo(select);
$('<option value="public">public').appendTo(select); wizard.setValue("importmode", select); _createForm.apply(this, [place, wizard, iframeName]); }; var _onGet = config.macros.importTiddlers.onGetTiddler; config.macros.importTiddlers.onGetTiddler = function(context, wizard) { var type =$(wizard.getValue("importmode")).val();
var ws =  plugin.getCurrentWorkspace(type);
wizard.setValue("workspace", ws);
_onGet.apply(this, [context, wizard]);
};
}

config.extensions.ServerSideSavingPlugin.reportSuccess = function(msg, tiddler) {
plugin.checkSyncStatus(tiddler);
msg = config.extensions.ServerSideSavingPlugin.locale[msg];
var link = "/" + encodeURIComponent(tiddler.title);
};

})(jQuery);
//}}}
/***
|''Author:''|FND|
|''Contributors''|Chris Dent, Martin Budden|
|''Version''|1.4.10|
|''Status''|stable|
|''CodeRepository''|http://svn.tiddlywiki.org/Trunk/association/|
|''CoreVersion''|2.5|
|''Keywords''|serverSide TiddlyWeb|
!Notes
!To Do
* createWorkspace
* document custom/optional context attributes (e.g. filters, query, revision) and tiddler fields (e.g. server.title, origin)
!Code
***/
//{{{
(function($) { var adaptor = config.adaptors.tiddlyweb = function() {}; adaptor.prototype = new AdaptorBase(); adaptor.serverType = "tiddlyweb"; adaptor.serverLabel = "TiddlyWeb"; adaptor.mimeType = "application/json"; adaptor.parsingErrorMessage = "Error parsing result from server"; adaptor.noBagErrorMessage = "no bag specified for tiddler"; adaptor.locationIDErrorMessage = "no bag or recipe specified for tiddler"; // TODO: rename // retrieve current status (requires TiddlyWeb status plugin) adaptor.prototype.getStatus = function(context, userParams, callback) { context = this.setContext(context, userParams, callback); var uriTemplate = "%0/status"; var uri = uriTemplate.format([context.host]); var req = httpReq("GET", uri, adaptor.getStatusCallback, context, null, null, null, null, null, true); return typeof req == "string" ? req : true; }; adaptor.getStatusCallback = function(status, context, responseText, uri, xhr) { context.status = responseText ? status : false; try { context.statusText = xhr.statusText; } catch(exc) { // offline (Firefox) context.status = false; context.statusText = null; } context.httpStatus = xhr.status; if(context.status) { context.serverStatus =$.evalJSON(responseText); // XXX: error handling!?
}
if(context.callback) {
context.callback(context, context.userParams);
}
};

// retrieve a list of workspaces
adaptor.prototype.getWorkspaceList = function(context, userParams, callback) {
context = this.setContext(context, userParams, callback);
context.workspaces = [];
var uriTemplate = "%0/recipes"; // XXX: bags?
var uri = uriTemplate.format([context.host]);
var req = httpReq("GET", uri, adaptor.getWorkspaceListCallback,
context, { accept: adaptor.mimeType }, null, null, null, null, true);
return typeof req == "string" ? req : true;
};

adaptor.getWorkspaceListCallback = function(status, context, responseText, uri, xhr) {
context.status = status;
context.statusText = xhr.statusText;
context.httpStatus = xhr.status;
if(status) {
try {
var workspaces = $.evalJSON(responseText); } catch(ex) { context.status = false; // XXX: correct? context.statusText = exceptionText(ex, adaptor.parsingErrorMessage); if(context.callback) { context.callback(context, context.userParams); } return; } context.workspaces = workspaces.map(function(itm) { return { title: itm }; }); } if(context.callback) { context.callback(context, context.userParams); } }; // retrieve a list of tiddlers adaptor.prototype.getTiddlerList = function(context, userParams, callback) { context = this.setContext(context, userParams, callback); var uriTemplate = "%0/%1/%2/tiddlers%3"; var params = context.filters ? "?" + context.filters : ""; if(context.format) { params = context.format + params; } var workspace = adaptor.resolveWorkspace(context.workspace); var uri = uriTemplate.format([context.host, workspace.type + "s", adaptor.normalizeTitle(workspace.name), params]); var req = httpReq("GET", uri, adaptor.getTiddlerListCallback, context, merge({ accept: adaptor.mimeType }, context.headers), null, null, null, null, true); return typeof req == "string" ? req : true; }; adaptor.getTiddlerListCallback = function(status, context, responseText, uri, xhr) { context.status = status; context.statusText = xhr.statusText; context.httpStatus = xhr.status; if(status) { context.tiddlers = []; try { var tiddlers =$.evalJSON(responseText); //# NB: not actual tiddler instances
} catch(ex) {
context.status = false; // XXX: correct?
if(context.callback) {
context.callback(context, context.userParams);
}
return;
}
for(var i = 0; i < tiddlers.length; i++) {
context.tiddlers.push(tiddler);
}
}
if(context.callback) {
context.callback(context, context.userParams);
}
};

// perform global search
adaptor.prototype.getSearchResults = function(context, userParams, callback) {
context = this.setContext(context, userParams, callback);
var uriTemplate = "%0/search?q=%1%2";
var filterString = context.filters ? ";" + context.filters : "";
var uri = uriTemplate.format([context.host, context.query, filterString]); // XXX: parameters need escaping?
var req = httpReq("GET", uri, adaptor.getSearchResultsCallback,
context, { accept: adaptor.mimeType }, null, null, null, null, true);
return typeof req == "string" ? req : true;
};

adaptor.getSearchResultsCallback = function(status, context, responseText, uri, xhr) {
adaptor.getTiddlerListCallback(status, context, responseText, uri, xhr); // XXX: use apply?
};

// retrieve a particular tiddler's revisions
adaptor.prototype.getTiddlerRevisionList = function(title, limit, context, userParams, callback) {
context = this.setContext(context, userParams, callback);
var uriTemplate = "%0/%1/%2/tiddlers/%3/revisions";
var uri = uriTemplate.format([context.host, workspace.type + "s",
var req = httpReq("GET", uri, adaptor.getTiddlerRevisionListCallback,
return typeof req == "string" ? req : true;
};

adaptor.getTiddlerRevisionListCallback = function(status, context, responseText, uri, xhr) {
context.status = status;
context.statusText = xhr.statusText;
context.httpStatus = xhr.status;
if(status) {
context.revisions = [];
try {
var tiddlers = $.evalJSON(responseText); //# NB: not actual tiddler instances } catch(ex) { context.status = false; // XXX: correct? context.statusText = exceptionText(ex, adaptor.parsingErrorMessage); if(context.callback) { context.callback(context, context.userParams); } return; } for(var i = 0; i < tiddlers.length; i++) { var tiddler = adaptor.toTiddler(tiddlers[i], context.host); context.revisions.push(tiddler); } var sortField = "server.page.revision"; context.revisions.sort(function(a, b) { return a.fields[sortField] < b.fields[sortField] ? 1 : (a.fields[sortField] == b.fields[sortField] ? 0 : -1); }); } if(context.callback) { context.callback(context, context.userParams); } }; // retrieve an individual tiddler revision -- XXX: breaks with standard arguments list -- XXX: convenience function; simply use getTiddler? adaptor.prototype.getTiddlerRevision = function(title, revision, context, userParams, callback) { context = this.setContext(context, userParams, callback); context.revision = revision; return this.getTiddler(title, context, userParams, callback); }; // retrieve an individual tiddler //# context is an object with members host and workspace //# callback is passed the new context and userParams adaptor.prototype.getTiddler = function(title, context, userParams, callback) { context = this.setContext(context, userParams, callback); context.title = title; if(context.revision) { var uriTemplate = "%0/%1/%2/tiddlers/%3/revisions/%4"; } else { uriTemplate = "%0/%1/%2/tiddlers/%3"; } if(!context.tiddler) { context.tiddler = new Tiddler(title); } context.tiddler.fields["server.type"] = adaptor.serverType; context.tiddler.fields["server.host"] = AdaptorBase.minHostName(context.host); context.tiddler.fields["server.workspace"] = context.workspace; var workspace = adaptor.resolveWorkspace(context.workspace); var uri = uriTemplate.format([context.host, workspace.type + "s", adaptor.normalizeTitle(workspace.name), adaptor.normalizeTitle(title), context.revision]); var req = httpReq("GET", uri, adaptor.getTiddlerCallback, context, merge({ accept: adaptor.mimeType }, context.headers), null, null, null, null, true); return typeof req == "string" ? req : true; }; adaptor.getTiddlerCallback = function(status, context, responseText, uri, xhr) { context.status = status; context.statusText = xhr.statusText; context.httpStatus = xhr.status; if(status) { try { var tid =$.evalJSON(responseText);
} catch(ex) {
context.status = false;
if(context.callback) {
context.callback(context, context.userParams);
}
return;
}
tiddler.title = context.tiddler.title;
// normally we'd assign context.tiddler = tiddler here - but we can't do
// that because of IE, which triggers getTiddler in putTiddlerCallback,
// and since ServerSideSavingPlugin foolishly relies on persistent
// object references, we need to merge the data into the existing object
$.extend(context.tiddler, tiddler); } if(context.callback) { context.callback(context, context.userParams); } }; // retrieve tiddler chronicle (all revisions) adaptor.prototype.getTiddlerChronicle = function(title, context, userParams, callback) { context = this.setContext(context, userParams, callback); context.title = title; var uriTemplate = "%0/%1/%2/tiddlers/%3/revisions?fat=1"; var workspace = adaptor.resolveWorkspace(context.workspace); var uri = uriTemplate.format([context.host, workspace.type + "s", adaptor.normalizeTitle(workspace.name), adaptor.normalizeTitle(title)]); var req = httpReq("GET", uri, adaptor.getTiddlerChronicleCallback, context, { accept: adaptor.mimeType }, null, null, null, null, true); return typeof req == "string" ? req : true; }; adaptor.getTiddlerChronicleCallback = function(status, context, responseText, uri, xhr) { context.status = status; context.statusText = xhr.statusText; context.httpStatus = xhr.status; if(status) { context.responseText = responseText; } if(context.callback) { context.callback(context, context.userParams); } }; // store an individual tiddler adaptor.prototype.putTiddler = function(tiddler, context, userParams, callback) { context = this.setContext(context, userParams, callback); context.title = tiddler.title; context.tiddler = tiddler; context.host = context.host || this.fullHostName(tiddler.fields["server.host"]); var uriTemplate = "%0/%1/%2/tiddlers/%3"; try { context.workspace = context.workspace || tiddler.fields["server.workspace"]; var workspace = adaptor.resolveWorkspace(context.workspace); } catch(ex) { return adaptor.locationIDErrorMessage; } var uri = uriTemplate.format([context.host, workspace.type + "s", adaptor.normalizeTitle(workspace.name), adaptor.normalizeTitle(tiddler.title)]); var etag = adaptor.generateETag(workspace, tiddler); var headers = etag ? { "If-Match": etag } : null; var payload = { type: tiddler.fields["server.content-type"] || null, text: tiddler.text, tags: tiddler.tags, fields:$.extend({}, tiddler.fields)
};
$.each(payload.fields, function(key, value) { if(key.indexOf("server.") == 0) { delete payload.fields[key]; } }); payload =$.toJSON(payload);
var req = httpReq("PUT", uri, adaptor.putTiddlerCallback,
return typeof req == "string" ? req : true;
};

adaptor.putTiddlerCallback = function(status, context, responseText, uri, xhr) {
context.status = [204, 1223].contains(xhr.status);
context.statusText = xhr.statusText;
context.httpStatus = xhr.status;
if(context.status) {
if(loc && etag) {
var bag = loc.split("/bags/").pop().split("/")[0];
context.tiddler.fields["server.bag"] = bag;
context.tiddler.fields["server.workspace"] = "bags/" + bag;
var rev = etag.split("/").pop().split(/;|:/)[0];
context.tiddler.fields["server.page.revision"] = rev;
context.tiddler.fields["server.etag"] = etag;
if(context.callback) {
context.callback(context, context.userParams);
}
} else { // IE
context.userParams, context.callback);
}
} else if(context.callback) {
context.callback(context, context.userParams);
}
};

// store a tiddler chronicle
adaptor.prototype.putTiddlerChronicle = function(revisions, context, userParams, callback) {
context = this.setContext(context, userParams, callback);
context.title = revisions[0].title;
var uriTemplate = "%0/%1/%2/tiddlers/%3/revisions";
var host = context.host || this.fullHostName(tiddler.fields["server.host"]);
var uri = uriTemplate.format([host, workspace.type + "s",
if(workspace.type == "bag") { // generate ETag
adaptor.normalizeTitle(context.title), 0].join("/"); //# zero-revision prevents overwriting existing contents
headers = { "If-Match": '"' + etag + '"' };
}
var payload = $.toJSON(revisions); var req = httpReq("POST", uri, adaptor.putTiddlerChronicleCallback, context, headers, payload, adaptor.mimeType, null, null, true); return typeof req == "string" ? req : true; }; adaptor.putTiddlerChronicleCallback = function(status, context, responseText, uri, xhr) { context.status = [204, 1223].contains(xhr.status); context.statusText = xhr.statusText; context.httpStatus = xhr.status; if(context.callback) { context.callback(context, context.userParams); } }; // store a collection of tiddlers (import TiddlyWiki HTML store) adaptor.prototype.putTiddlerStore = function(store, context, userParams, callback) { context = this.setContext(context, userParams, callback); var uriTemplate = "%0/%1/%2/tiddlers"; var host = context.host; var workspace = adaptor.resolveWorkspace(context.workspace); var uri = uriTemplate.format([host, workspace.type + "s", adaptor.normalizeTitle(workspace.name)]); var req = httpReq("POST", uri, adaptor.putTiddlerStoreCallback, context, null, store, "text/x-tiddlywiki", null, null, true); return typeof req == "string" ? req : true; }; adaptor.putTiddlerStoreCallback = function(status, context, responseText, uri, xhr) { context.status = [204, 1223].contains(xhr.status); context.statusText = xhr.statusText; context.httpStatus = xhr.status; if(context.callback) { context.callback(context, context.userParams); } }; // rename an individual tiddler or move it to a different workspace -- TODO: make {from|to}.title optional //# from and to are objects with members title and workspace (bag; optional), //# representing source and target tiddler, respectively adaptor.prototype.moveTiddler = function(from, to, context, userParams, callback) { // XXX: rename parameters (old/new)? var self = this; var newTiddler = store.getTiddler(from.title) || store.getTiddler(to.title); //# local rename might already have occurred var oldTiddler =$.extend(true, {}, newTiddler); //# required for eventual deletion
oldTiddler.title = from.title; //# required for original tiddler's ETag
var _getTiddlerChronicle = function(title, context, userParams, callback) {
return self.getTiddlerChronicle(title, context, userParams, callback);
};
var _putTiddlerChronicle = function(context, userParams) {
if(!context.status) {
return callback(context, userParams);
}
var revisions = $.evalJSON(context.responseText); // XXX: error handling? // change current title while retaining previous location for(var i = 0; i < revisions.length; i++) { delete revisions[i].revision; if(!revisions[i].fields.origin) { // NB: origin = "<workspace>/<title>" revisions[i].fields.origin = ["bags", revisions[i].bag, revisions[i].title].join("/"); } revisions[i].title = to.title; } // add new revision var rev =$.extend({}, revisions[0]);
$.each(newTiddler, function(i, item) { if(!$.isFunction(item)) {
rev[i] = item;
}
});
rev.title = to.title;
rev.created = rev.created.convertToYYYYMMDDHHMM();
rev.modified = new Date().convertToYYYYMMDDHHMM();
delete rev.fields.changecount;
revisions.unshift(rev);
if(to.workspace) {
context.workspace = to.workspace;
} else if(context.workspace.substring(0, 4) != "bags") { // NB: target workspace must be a bag
context.workspace = "bags/" + rev.bag;
}
var subCallback = function(context, userParams) {
if(!context.status) {
return callback(context, userParams);
}
};
return self.putTiddlerChronicle(revisions, context, context.userParams, subCallback);
};
var _deleteTiddler = function(context, userParams) {
if(!context.status) {
return callback(context, userParams);
}
$.extend(true, newTiddler, context.tiddler); context.callback = null; return self.deleteTiddler(oldTiddler, context, context.userParams, callback); }; callback = callback || function() {}; context = this.setContext(context, userParams); context.host = context.host || oldTiddler.fields["server.host"]; context.workspace = from.workspace || oldTiddler.fields["server.workspace"]; return _getTiddlerChronicle(from.title, context, userParams, _putTiddlerChronicle); }; // delete an individual tiddler adaptor.prototype.deleteTiddler = function(tiddler, context, userParams, callback) { context = this.setContext(context, userParams, callback); context.title = tiddler.title; // XXX: not required!? var uriTemplate = "%0/bags/%1/tiddlers/%2"; var host = context.host || this.fullHostName(tiddler.fields["server.host"]); var bag = tiddler.fields["server.bag"]; if(!bag) { return adaptor.noBagErrorMessage; } var uri = uriTemplate.format([host, adaptor.normalizeTitle(bag), adaptor.normalizeTitle(tiddler.title)]); var etag = adaptor.generateETag({ type: "bag", name: bag }, tiddler); var headers = etag ? { "If-Match": etag } : null; var req = httpReq("DELETE", uri, adaptor.deleteTiddlerCallback, context, headers, null, null, null, null, true); return typeof req == "string" ? req : true; }; adaptor.deleteTiddlerCallback = function(status, context, responseText, uri, xhr) { context.status = [204, 1223].contains(xhr.status); context.statusText = xhr.statusText; context.httpStatus = xhr.status; if(context.callback) { context.callback(context, context.userParams); } }; // compare two revisions of a tiddler (requires TiddlyWeb differ plugin) //# if context.rev1 is not specified, the latest revision will be used for comparison //# if context.rev2 is not specified, the local revision will be sent for comparison //# context.format is a string as determined by the TiddlyWeb differ plugin adaptor.prototype.getTiddlerDiff = function(title, context, userParams, callback) { context = this.setContext(context, userParams, callback); context.title = title; var tiddler = store.getTiddler(title); try { var workspace = adaptor.resolveWorkspace(tiddler.fields["server.workspace"]); } catch(ex) { return adaptor.locationIDErrorMessage; } var tiddlerRef = [workspace.type + "s", workspace.name, tiddler.title].join("/"); var rev1 = context.rev1 ? [tiddlerRef, context.rev1].join("/") : tiddlerRef; var rev2 = context.rev2 ? [tiddlerRef, context.rev2].join("/") : null; var uriTemplate = "%0/diff?rev1=%1"; if(rev2) { uriTemplate += "&rev2=%2"; } if(context.format) { uriTemplate += "&format=%3"; } var host = context.host || this.fullHostName(tiddler.fields["server.host"]); var uri = uriTemplate.format([host, adaptor.normalizeTitle(rev1), adaptor.normalizeTitle(rev2), context.format]); if(rev2) { var req = httpReq("GET", uri, adaptor.getTiddlerDiffCallback, context, null, null, null, null, null, true); } else { var payload = { title: tiddler.title, text: tiddler.text, modifier: tiddler.modifier, tags: tiddler.tags, fields:$.extend({}, tiddler.fields)
}; // XXX: missing attributes!?
payload = $.toJSON(payload); req = httpReq("POST", uri, adaptor.getTiddlerDiffCallback, context, null, payload, adaptor.mimeType, null, null, true); } return typeof req == "string" ? req : true; }; adaptor.getTiddlerDiffCallback = function(status, context, responseText, uri, xhr) { context.status = status; context.statusText = xhr.statusText; context.httpStatus = xhr.status; context.uri = uri; if(status) { context.diff = responseText; } if(context.callback) { context.callback(context, context.userParams); } }; // generate tiddler information adaptor.prototype.generateTiddlerInfo = function(tiddler) { var info = {}; var uriTemplate = "%0/%1/%2/tiddlers/%3"; var host = this.host || tiddler.fields["server.host"]; // XXX: this.host obsolete? host = this.fullHostName(host); var workspace = adaptor.resolveWorkspace(tiddler.fields["server.workspace"]); info.uri = uriTemplate.format([host, workspace.type + "s", adaptor.normalizeTitle(workspace.name), adaptor.normalizeTitle(tiddler.title)]); return info; }; // create Tiddler instance from TiddlyWeb tiddler JSON adaptor.toTiddler = function(json, host) { var created = Date.convertFromYYYYMMDDHHMM(json.created); var modified = Date.convertFromYYYYMMDDHHMM(json.modified); var fields = json.fields; fields["server.type"] = adaptor.serverType; fields["server.host"] = AdaptorBase.minHostName(host); fields["server.bag"] = json.bag; fields["server.title"] = json.title; if(json.recipe) { fields["server.recipe"] = json.recipe; } if(json.type && json.type != "None") { fields["server.content-type"] = json.type; } fields["server.permissions"] = json.permissions.join(", "); fields["server.page.revision"] = json.revision; fields["server.workspace"] = "bags/" + json.bag; var tiddler = new Tiddler(json.title); tiddler.assign(tiddler.title, json.text, json.modifier, modified, json.tags, created, json.fields, json.creator); return tiddler; }; adaptor.resolveWorkspace = function(workspace) { var components = workspace.split("/"); return { type: components[0] == "bags" ? "bag" : "recipe", name: components[1] || components[0] }; }; adaptor.generateETag = function(workspace, tiddler) { var revision = tiddler.fields["server.page.revision"]; var etag = revision == "false" ? null : tiddler.fields["server.etag"]; if(!etag && workspace.type == "bag") { if(typeof revision == "undefined") { revision = "0"; } else if(revision == "false") { return null; } etag = [adaptor.normalizeTitle(workspace.name), adaptor.normalizeTitle(tiddler.title), revision].join("/"); etag = '"' + etag + '"'; } return etag; }; adaptor.normalizeTitle = function(title) { return encodeURIComponent(title); }; })(jQuery); /* * jQuery JSON Plugin * version: 1.3 * source: http://code.google.com/p/jquery-json/ * license: MIT (http://www.opensource.org/licenses/mit-license.php) */ (function($){function toIntegersAtLease(n)
{return n<10?'0'+n:n;}
Date.prototype.toJSON=function(date)
{return this.getUTCFullYear()+'-'+
toIntegersAtLease(this.getUTCMonth())+'-'+
toIntegersAtLease(this.getUTCDate());};var escapeable=/["\\\x00-\x1f\x7f-\x9f]/g;var meta={'\b':'\\b','\t':'\\t','\n':'\\n','\f':'\\f','\r':'\\r','"':'\\"','\\':'\\\\'};$.quoteString=function(string) {if(escapeable.test(string)) {return'"'+string.replace(escapeable,function(a) {var c=meta[a];if(typeof c==='string'){return c;} c=a.charCodeAt();return'\\u00'+Math.floor(c/16).toString(16)+(c%16).toString(16);})+'"';} return'"'+string+'"';};$.toJSON=function(o,compact)
{var type=typeof(o);if(type=="undefined")
return"undefined";else if(type=="number"||type=="boolean")
return o+"";else if(o===null)
return"null";if(type=="string")
{return $.quoteString(o);} if(type=="object"&&typeof o.toJSON=="function") return o.toJSON(compact);if(type!="function"&&typeof(o.length)=="number") {var ret=[];for(var i=0;i<o.length;i++){ret.push($.toJSON(o[i],compact));}
if(compact)
return"["+ret.join(",")+"]";else
return"["+ret.join(", ")+"]";}
if(type=="function"){throw new TypeError("Unable to convert object of type 'function' to json.");}
var ret=[];for(var k in o){var name;type=typeof(k);if(type=="number")
name='"'+k+'"';else if(type=="string")
name=$.quoteString(k);else continue;var val=$.toJSON(o[k],compact);if(typeof(val)!="string"){continue;}
if(compact)
ret.push(name+":"+val);else
ret.push(name+": "+val);}
return"{"+ret.join(", ")+"}";};$.compactJSON=function(o) {return$.toJSON(o,true);};$.evalJSON=function(src) {return eval("("+src+")");};$.secureEvalJSON=function(src)
{var filtered=src;filtered=filtered.replace(/\$"\\\/bfnrtu]/g,'@');filtered=filtered.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,']');filtered=filtered.replace(/(?:^|:|,)(?:\s*\[)+/g,'');if(/^[$,:{}\s]*/.test(filtered)) return eval("("+src+")");else throw new SyntaxError("Error parsing JSON, source is not valid.");};})(jQuery); //}}}   /*{{{*/ .tiddler .originButton div { display: inline-block; } .tiddler .spaceSiteIcon .siteIcon { _display: inline; /* IE doesn't like inline-block */ } .tiddler .originButton { display: block; } .selected .tagging, .selected .tagging:hover { border: none; background: none; } .tagging { float: none; background: none; border: none; } .tagging li.listTitle { margin-left: 0px; } .tagging li { margin: 0 8px; } .tagging .tiddlyLink { -webkit-border-radius: 3px; -moz-border-radius: 3px; -o-border-radius: 3px; border-radius: 3px; padding: 1px 2px; line-height: 1.2em; } /* for following */ #popup .siteIcon { float: left; height: 25px; } .content { width: 100%; /* IE */ font-size: 0.9em; } .editorHeading { height: 48px; } .heading { left: 0; margin-bottom: 40px; position: relative; top: 32px; } .followButton a { display: block; margin-top: -20px; } .tiddler .followPlaceHolder { display: block; position: absolute; top: 16px; right: 64px; _right: 138px; // add width of modifierIcon } .tiddler .followButton { position: relative; height: 24px; text-align: left; color: #fff; background: [[ColorPalette::PrimaryMid]]; padding: 10px 0px 0px 10px; width: 38px; margin: -16px -8px 24px 0; } /* creates the larger triangle */ .followButton:before { content: "\00a0"; display: block; /* reduce the damage in FF3.0 */ position: relative; bottom: -20px; right: 0; width: 0; height: 0; border-width: 0 0 20px 20px; border-style: solid; border-color: transparent [[ColorPalette::PrimaryMid]]; } .toolbar svg { height: 16px; width: 16px; } .toolbar svg .glyph { fill: #ccc; } .toolbar a:hover .glyph { fill: black; } .toolbar a:active .glyph { fill: [[ColorPalette::Background]]; } .originButton, .followPlaceHolder, .tiddler .subtitle { cursor: pointer; } .editSpaceSiteIcon .originButton { cursor: auto; } .tiddler .subtitle:hover { font-weight: bold; background: none; } .originButton img, .originButton svg { margin-left: 0px; } .modifierIcon { position: absolute; width: 74px; top: 0px; right: 0px; _right: 74px; /* in IE6 positioning works incorrectly so use -width instead */ text-align: right; } .modifierIcon img, .modifierIcon svg { margin-right: 8px; } .tiddler .viewer { padding-bottom: 16px; margin: 0 0 0 56px; line-height: 1.4em; } .viewer pre { margin-left: 0; } .siteIcon .label { color: [[ColorPalette::TertiaryDark]]; } .tiddler .spaceSiteIcon { float: left; margin-right: 0; margin-top: 0; position: relative; display: block; } .tiddler .titleBar { display: block; margin-right: 136px; margin-left: 56px; } .followButton a { color: [[ColorPalette::Background]]; } .tiddler { position: relative; padding: 0; margin-bottom: 3em; border-top: 3px solid [[ColorPalette::PrimaryMid]]; background: #fff; } .tiddler .editor { padding: 0px 8px; } .tiddler .heading .title { position: relative; display: block; word-wrap: break-word; font-size: 32px; line-height: 32px; } .tiddler .heading .editor.title { font-size: 1.7em; line-height: normal; } .tiddler .headingClear { clear: both; } .tiddler .subtitle { font-style: italic; font-size: 0.9em; color: #a6a59e; margin-top: 0; } .toolbar { position: absolute; padding: 0; top: 8px; right: -8px; } .toolbar .moreCommand.highlight { background: none; } .tiddler .toolbar .button { border: none; display: inline; padding: 0px; margin-right: 16px; } .tiddler .toolbar a:hover { background: none; } .tiddler .tagged .listTitle { display: none; } .revButton { float: right; } /*! EditTemplate specific*/ .tiddler .privacySettings { text-align: center; } .tiddler .privacySettings .originButton { display: inline; } .editSpaceSiteIcon, .privacyEdit { float: left; } .editSpaceSiteIcon svg, .editSpaceSiteIcon img, .editSpaceSiteIcon .roundelLabel { float: left; } .tagTitle { position: absolute; text-align: center; width: 48px; top: 0px; left: -56px; } .editSpaceSiteIcon .originButton img, .editSpaceSiteIcon .originButton svg { height: 16px; margin-left: 24px; margin-right: 32px; width: 16px; } .tagAnnotation { margin-top: 8px; padding-bottom: 8px; } .annotationsBox { margin-top: 8px; } .editorFooter { position: relative; padding: 0; margin-top: 16px; margin-left: 64px; } .tiddler .editorFooter .editor { padding-left: 0px; } .heading .editor input { width: 100%; font-size: 1.5em; } .spaceSiteIcon .externalImage .image a:hover, .modifierIcon .externalImage .image a:hover { background: none; } div.toolbar { visibility:hidden; right:-16px; } .selected div.toolbar { visibility: visible; } .followButton a:hover { background: [[ColorPalette::PrimaryMid]]; text-decoration: underline; } a.image:hover { background: transparent; } @media all and (max-device-width: 480px) { div.toolbar { visibility:visible; } } @media only screen and (device-width: 768px) { div.toolbar { visibility:visible; } } @media all and (max-width: 960px) { .tiddler .titleBar { margin-left: 36px; margin-right: 80px; } .tiddler .heading { margin-bottom: 48px; } .tiddler .heading .title { font-size: 32px; line-height: 32px; } .tiddler .modifierIcon img, .tiddler .modifierIcon svg, .tiddler .spaceSiteIcon .originButton img, .originButton svg { width: 32px; height: 32px; margin-left: 0px; margin-right: 0px; } .tiddler .followPlaceHolder { right: 48px; } .tiddler .followButton { width: 24px; } .tiddler .viewer { margin: 0px 0px 0px 36px; padding-top: 0; } br { line-height: 0.5em; } } /*}}}*/ ColorPalette StyleSheet SiteSubtitle GettingStarted SiteTitle MainMenu SiteIcon DefaultTiddlers ViewTemplate PageTemplate SideBarOptions EditTemplate SiteInfo SideBarTabs ToolbarCommands !!Parent page We are looking for a Ramsey property and we want to know [[what features it should have|If we want a Ramsey property, then what features should it have?]]. !Introduction One way of expressing the question we are asking is this. What relates to a complexity structure as a strategic subtree relates to a tree? Our plan is to make an initial guess at an answer, try to prove that it has the properties we are looking for, <<slider chkWhatProperties "What properties are we looking for?" "What are those?" "Reminder of desired properties">> and then make changes to the guess if we are driven to do so. !Can we describe strategic subtrees in a way that doesn't mention trees? What I mean by this is that it would be nice if we could describe some general notion of a substructure of a structure that gives us a strategic subtree in the case where the structure is a tree. Then we could see what it gives us when the structure is a complexity structure. I think this may be a bit ambitious, but it's worth a quick try just in case. One problem is that strategic subtrees make use of //levels//, which are a fairly tree-specific concept. Before I worry about that, perhaps there is a more fundamental question that should be addressed: what would serve as a good simultaneous generalization of the notion of a tree and the notion of a complexity structure? An advantage of thinking about that is that there might be other examples that are somehow intermediate between the two. Or is a tree a special kind of complexity structure? I'd better think about that. [[ClarifyConcept|Is a tree a special kind of complexity structure?]] And the answer turns out to be that it is, in a fairly trivial way. We identify each leaf in the tree with the sequence of vertices from the root to that leaf, not including the root itself. This can be thought of as giving us a subset $$X$$ of $$V^n$$, where $$V$$ is the vertex set of the tree and $$n$$ is the number of levels. What is useful about this is that the Hamming distance on $$X$$ coincides with (half) the graph distance between the leaves. !Does the intersection property help? Recall that a strategic subtree for Player I intersects a strategic subtree for Player II in exactly one path. That is a consequence of the trivial fact that the set of all successors of a vertex intersects a set that consists of just one successor in exactly one successor. If there are $$r$$ successors and we want to guarantee an intersection in at least one successor, then another way of doing it is to take a set of $$s$$ successors and a set of $$t$$ successors, with $$s+t>r$$. That thought leads quickly to an observation of another Ramsey property, this time more symmetrical. Suppose for convenience that we have a $$2r-1$$-ary tree with $$n$$ levels. Let $$A$$ be a subset of its leaves. I claim that either $$A$$ or $$A^c$$ contains all the leaves of an $$r$$-ary subtree that contains the root. The proof is a simple inductive argument (as is the proof of determinacy). Indeed, either $$r$$ children of the root are joined to $$A$$ by $$r$$-ary trees or $$r$$ children of the root are //not// joined to $$A$$ by $$r$$-ary trees. But by induction, any child that is not joined to $$A$$ by an $$r$$-ary tree is joined to $$A^c$$ by an $$r$$-ary tree, so we are done. Since we are trying to make things more symmetrical, it seems nicer to look for subtrees that are everywhere "fat" rather than for subtrees where every other level is "very fat". Note that two $$r$$-ary subtrees of a $$2r-1$$-ary tree must intersect in at least a path. Note also that the notion of "fat" has analogues in other graphs: it's basically a minimum degree condition. For example, we could define a fat subgraph of the discrete cube to be a subgraph that contains at least one vertex and for which each vertex (in the subgraph) has degree at least half the dimension of the cube. (An example of such a subgraph would be the graph induced by an affine subspace obtained by fixing half the coordinates, but it would not be the only example.) !What can be done with the notion of "fat" subgraphs? What I have been calling a tree structure on $$\{0,1\}^n$$ is not a set of edges between the points of $$\{0,1\}^n$$ that makes it into a tree. Rather, it is a tree whose //leaves// are the points of $$\{0,1\}^n$$. That makes things harder: it's not quite clear how a more general graph might interact with a more general complexity structure. However, it doesn't really seem to be the graph structure on a tree that is important, so much as the metric on $$\{0,1\}$$ to which it gives rise. So let us try to characterize sets that are the set of leaves of some fat subtree in terms of the metric obtained by the tree. Again, for simplicity I'll consider the case where the tree is a $$2r-1$$-ary tree. Then there are $$(2r-1)^n$$ leaves and the metric on the set $$X$$ of leaves looks like this. Each vertex has distance 1 from $$2r-2$$ other vertices, distance 2 from a further $$(2r-2)^2$$ vertices, distance 3 from a further $$(2r-2)^3$$ vertices, and so on. An "at least $$r$$-ary subset" of $$X$$ is then a subset $$Y$$ that contains at least one point and has the following further property: if $$y,z\in Y$$ and $$d(y,z)=d$$, then the ball of radius $$d$$ about $$y$$ contains at least $$(r-1)^d$$ points of $$Y$$. This charcterizes the sets that can arise as leaves of a tree that contains the root and for which each vertex has at least $$r$$ children. <<slider chkFatSubtreeCharacterization "Is this characterization of leaf sets of r-ary subtrees correct?" "Check this" "Check that this characterization is correct">> This feels like a definition of what one might call a "half-dimensional" set. I say that for various reasons. One is that if we have a regular tree and we go back to strategic subtrees, then the number of leaves of a strategic subtree is comparable to the square root of the total number of leaves. Also, in $$\{0,1\}^n$$ a good example of an induced subgraph of the graph where every vertex has half the degree it has in the whole graph is an affine subspace of $$n/2$$ dimensions obtained by fixing $$n/2$$ coordinates. And finally, we are looking for a fairly flexible class of subsets such that any two of them are guaranteed to intersect (or perhaps such that they "typically" intersect). Subsets that are in some sense "half-dimensional" seem like a good candidate. But do we actually have a definition that applies to a sufficiently wide class of discrete metric spaces? I've given a metric definition in the tree case, but how should it be generalized? [[TryToFormulateDefinition|What is the right definition of a "half-dimensional set"?]]
 OK, we have a rough plan, which is as follows. We take a sequence of radii $$r_1<r_2<\dots<r_k$$ and inductively define a set to be half-dimensional in a ball $$B$$ of radius $$r_i$$ if for over half (measured by some natural probability measure that reflects the amount of overlap with $$B$$) the balls of radius $$r_{i-1}$$ near $$B$$ the set is half-dimensional in those balls. And a set is half-dimensional in a ball of radius $$r_1$$ if it contains over half that ball. That way, we have a simple proof of the Ramsey property that for every set $$A$$, either $$A$$ or its complement is half-dimensional. It may be hard to define "half-dimensional" in such a way that we can force any two half-dimensional sets to intersect, but if we can, then it will not be possible for both a set and its complement to be half-dimensional, which would be a nice extra property, but one we can probably dispense with if it is too much trouble to obtain it. Rather than sorting out all these details now, I want to check that it is not easy to lift an arbitrary subset of $$\{0,1\}^n$$ to a simple set using a lift that takes half-dimensional sets to half-dimensional sets. It may be possible to decide that without a precise definition of "half-dimensional". [[TryWeakerQuestion|Is it easy to Ramsey-lift an arbitrary set to a simple set?]]  !!Parent page We are wondering [[what a strange simplicity property could be like|What could a "strange" simplicity property conceivably be like?]]. !Introduction We have identified (using informal arguments) the need to bridge a certain gap between """NP-ish""" properties and """co-NP-ish""" properties. Before we turn our attention to the question of whether there could be some useful "intermediate" properties that would serve this purpose, we shall consider on this page whether one can "jump" the gap by going directly from a naturally existential statement to a naturally universal one. Rather than look at the particular case at hand, we will begin by considering a far weaker question: how is it ever possible to deduce a universal statement from an existential one? !!Answers that are too trivial to be interesting 1. Suppose we have any statement of the form $$\exists x\ P(x)$$. If we want to deduce a universal statement from it, we can go for the statement $$\forall y\ \exists x\ Q(x,y)$$, where $$Q(x,y)$$ holds if and only if $$P(x)$$ holds. Obviously, this is not a interesting deduction at all. It is also an extreme case of a more general technique of producing uninteresting deductions. A good sign that it is uninteresting is that we can change the order of quantification to $$\exists x\ \forall y\ Q(x,y)$$ without affecting the truth value of the statement. What we are looking for is a deduction where the universal statement is very hard to rephrase as an existential one. 2. If we are allowed second-order quantification, then the process of Skolemization allows us to rewrite a statement of the form $$\forall x\ \exists y\ P(x,y)$$ as one of the form $$\exists f\ \forall x\ P(x,f(x))$$. However, this is a cheat, since the quantification over $$f$$ is over all functions from the set where $$x$$ lives to the set where $$y$$ lives, so the equivalence is between a second-order quantification and a first-order quantification. !!A slightly more interesting example One version of the Hahn-Banach separation theorem tells us that if $$K$$ and $$L$$ are two disjoint closed convex sets in a real Banach space $$X$$ and $$L$$ is compact, then there exists a continuous linear functional $$\phi$$ and a real number $$t$$ such that $$\phi(x)<t$$ for every $$x\in K$$ and $$\phi(y)>t$$ for every $$y\in L$$. The disjointness condition here is naturally phrased in a universal way: $$\forall x\in K\ \forall y\in L\ x\ne y$$. However, the conclusion, that there is a continuous linear functional that witnesses the disjointness, is naturally existential. Moreover, because the witness takes a particularly simple form -- it is just an element of the dual space $$X^*$$ -- the existential statement can sometimes be regarded as no less first order" than the original statement. This is particularly true in concrete spaces where the dual space can be intrinsically described. If it is described abstractly as the space of all continuous linear functionals on $$X$$, then it is more questionable whether quantification over $$X^*$$ should count as first-order quantification. (I am speaking very informally here.) The trouble with this example is that the implication goes from universal to existential rather than the other way round. That might not seem to be a problem, because the statement is actually an equivalence. But the existence of the linear functional implies the separation property rather trivially -- it is the universal-to-existential implication that is the interesting one. !!Another example If there is an injection from a set $$X$$ to $$\mathbb{N}$$, then it follows that there is no surjection from $$X$$ to $$\mathbb{R}$$. This is an example of the deduction of a universal statement (presented as the negation of an existential statement) from an existential statement. How does it work? Well, the first statement is equivalent to the existence of a surjection from $$\mathbb{N}$$ to $$X$$. So we can argue as follows: if there is a surjection from $$X$$ to $$\mathbb{R}$$ then composing the two surjections gives us a surjection from $$\mathbb{N}$$ to $$\mathbb{R}$$, which we know does not exist. So in order to deduce our universal conclusion about $$X$$ and $$\mathbb{R}$$ from our existential hypothesis about $$X$$ and $$\mathbb{N}$$, we are using a universal result about $$\mathbb{N}$$ and $$\mathbb{R}$$. !What next? I thought I had something more interesting to say here, but when I tried to write it down I didn't manage to convince myself. ''//Open task: give some interesting examples of deductions of universal statements from existential ones.//'' [[Back to parent page|What could a "strange" simplicity property conceivably be like?]]  !!Parent page We are trying to [[assess whether the shrinking-neighbourhoods game is likely to work for our purposes|Is the shrinking neighbourhoods game likely to work for our purposes?]]. !Introduction It seems to be hard, given a set $$A\subset\{0,1\}^n$$, to design an efficient Ramsey lift that turns $$A$$ into a simple set, not least because it is not clear what we should take as our definition of "simple". Another approach to the problem is to try to find as many interesting examples of efficient Ramsey lifts as we can, without worrying too much about the effect they have on any particular subset of $$\{0,1\}^n$$. Maybe if we have a good supply of such lifts, we will find that some of them, or combinations of some of them, or modifications of some of them, will have simplifying effects. !First attempt The "trivial lift", defined [[on this page|Is there an easy Ramsey lifting that makes all sets simple?]] (see "A fifth attempt"), requires Player I to declare a """I-winning""" set and Player II to declare a point in that set. That is very expensive, because the number of """I-winning""" sets is doubly exponential. Can we define a Ramsey lift in a similar way, but restricting Player I to playing something more like a strategy for the first few moves, and restricting Player II to a response to that strategy? The following definition is a guess. (I see it as the opening move in a game of """GuessAndAdjust""".) As a matter of fact, I now realize that I am about to repeat some material from [[this page|Is there a whole class of methods that are ruled out for similar reasons?]], but I think it is appropriate, and I may modify it slightly. By a //coordinate specification// I mean a statement of the form $$x_i=\gamma_i$$, where $$X\subset\Gamma_1\times\dots\times\Gamma_n$$ and $$\gamma_i\in\Gamma_i$$. By a //specification set// I mean a set $$S$$ of coordinate specifications no two of which specify the same coordinate. I call a set $$\Sigma$$ of specification sets //unavoidable// if no matter how the players play, at some point the set of specifications made so far will be one of the sets $$S\in\Sigma$$. An example is the set of all specification sets that consist of exactly four coordinate specifications. I will call $$\Sigma$$ //"""I-winning"""// if Player I has a winning strategy for reaching a set $$S\in\Sigma$$ and //"""II-winning"""// if Player II has such a strategy. Let $$\Sigma$$ be an unavoidable set of specification sets on $$X$$. For convenience I will take all sets in $$\Sigma$$ to consist of an even number of specifications. I will also assume that the specifications in $$S$$ form an antichain (meaning that no specification set contains any other). Then I will define a lift $$pi:Y\to X$$ as follows. The elements of $$Y$$ consist of sequences $$y=(y_1,\dots,y_n)$$ such that, setting $$m=n/2$$, we have the following properties. #For exactly one $$i\leq m$$, $$y_i$$ is a pair $$(\gamma_i,\Theta)$$, where $$\gamma_i\in\Gamma_i$$ and $$\Theta$$ is a """I-winning""" subset of $$\Sigma$$ for which the move $$x_i=\gamma_i$$ is the first move of a winning strategy for Player I. #For all other $$i\leq m$$, $$y_i=\gamma_i$$ for some $$\gamma_i\in\Gamma_i$$. #For every $$j>m$$, $$y_j$$ is a pair $$(\gamma_j,S)$$, where $$S\in\Theta$$. #The sequence $$(\gamma_1,\dots,\gamma_n)$$ obeys the specifications in $$S$$. Given such a sequence $$y$$, we define $$\pi(y)$$ to be $$(\gamma_1,\dots,\gamma_n)$$. !!!Is that a Ramsey lift? !!!!Winning sets for Player I Let $$W\subset Y$$ be a """I-winning""" set and let $$\sigma$$ be a winning strategy for Player I for getting into $$W$$. Then Player I's first move in the strategy $$\sigma$$ is of one of two kinds. ''Case 1: the move takes the form $$y_i=(\gamma_i,\Theta)$$.'' We have a problem here. What we would like to do is play until we get to some specification set $$S\in\Theta$$ and regard that as the set that Player II has played in the auxiliary game. But if Player II plays $$S$$ in the auxiliary game, it is not clear that the strategy $$\sigma$$ will cause Player I to reach the specification $$S$$: maybe she will specify coordinates other than the ones specified by $$S$$ before she makes all the specifications in $$S$$. I met this problem on the other page, and I think it can be dealt with as follows. Let Player I indeed play a strategy that is guaranteed to reach some $$S\in\Theta$$. When it does, the rest of the game needs to be played in a way that will produce a sequence that could have been produced in the auxiliary game if Player II's first move had been $$y_j=(\gamma_j,S)$$, where the move in the real game was $$x_j=\gamma_j$$. In the auxiliary game, after Player II's first move, the two players will have to make "dummy" moves where they specify coordinates in $$S$$ that are already forced by Property 4 in the definition of $$Y$$. In the real game this is not an option, because the moves in $$S$$ have already been made. Suppose Player II has a winning strategy $$\tau$$, once the game has reached the specification $$S$$, for ending up in a set $$V$$. He can convert that into a winning strategy in the auxiliary game for getting into $$\pi^{-1}(V)$$ once he has played his first move and declared the specification set $$S$$. This he does as follows. Note that all specification sets in $$\Sigma$$ specify the same number of coordinates for each player. Each time Player I plays a move in $$S$$ in the auxiliary game, Player II matches it with another move in $$S$$. Each time Player I plays a move outside $$S$$, then Player II looks at the set of specifications not in $$S$$ and does whatever $$\tau$$ dictates in response to that set. Now let's go back to what Player I does. She begins by forcing the game to reach some $$S\in\Theta$$. Once it does, she imagines that Player II declared $$S$$ in the auxiliary game. (She doesn't know in advance which $$S\in\Theta$$ she is going to end up in.) In the auxiliary game, she has a winning strategy for arriving in $$W$$ given that the opening move of Player II involves a declaration of $$S$$. I claim that this implies that she has a winning strategy in the real game for arriving in $$\pi(W)$$. If she doesn't, then Player II has a strategy in the real game for arriving in $$\pi(W)^c$$, which implies, by what we have just observed, that he has a strategy in the auxiliary game for arriving in $$\pi^{-1}(\pi(W)^c)$$ after the declaration of $$S$$. But that contradicts the fact that Player I has a winning strategy for arriving in $$W$$. ''Case 2. The move takes the form $$y_i=\gamma_i$$.'' Player II can respond to this move with any move of the form $$y_j=(\gamma_j,S)$$ as long as $$S\in\Sigma$$ includes the two specifications made so far, and Player I will win the auxiliary game. Thus, for every $$S\in\Sigma$$ that includes the specification $$x_i=\gamma_i$$ and for every Player II specification $$x_j=\gamma_j$$ in $$S$$, Player I has a winning strategy for reaching $$\pi(W)$$ under the condition that the moves $$x_i=\gamma_i$$ and $$x_j=\gamma_j$$ have been played, and the eventual sequence must be compatible with $$S$$. This gives Player I the following option for a strategy. She begins with the move $$x_i=\gamma_i$$. After that, she waits until a sequence $$S\in\Sigma$$ is reached, which is guaranteed to happen because $$\Sigma$$ is an unavoidable set. Suppose that at this point Player II has a winning strategy $$\rho$$ for getting to $$\pi(W)^c$$. Then he can convert it into a winning strategy in the auxiliary game with initial moves $$y_i=\gamma_i$$ and $$y_j=(\gamma_j,S)$$, which is, as above, to respond to each specification in $$S$$ with a specification in $$S$$, and otherwise to do what $$\rho$$ dictates, given the specifications outside $$S$$. Again, this is a contradiction, from which it follows that Player I has a winning strategy for getting to $$\pi(W)$$. !!!!Winning sets for Player II Now suppose that $$V$$ is a """II-winning""" subset of $$Y$$ and that $$\sigma$$ is a winning strategy for Player II for getting into $$V$$. Then for every first move $$y_i=(\gamma_i,\Theta)$$ that Player I can make, Player II has a response $$y_j=(\gamma_j,S)$$, from which he is in a position to get into $$V$$. Thus, for every opening move $$y_i=(\gamma_i,\Theta)$$ that Player I can make, there exists a specification set $$S\in\Theta$$ that Player II will play in response, and one of the specifications in $$S$$ will be $$x_i=\gamma_i$$. But if every """I-winning""" set has an element in some other set, then that other set is a """II-winning""" set (because its complement cannot be a """I-winning""" set and the game is finite, so determined). So Player II has the following winning strategy for getting into $$\pi(V)$$. First, he plays so as to force the set of specifications so far to be some $$S$$ that would be his response in the auxiliary game to a move of the form $$y_i=(\gamma_i,\Theta)$$. He must be able to do this, because if he couldn't, then Player I would have a strategy for forcing a set in $$\Sigma\setminus\Theta$$, and if she played the first move $$y_i=(\gamma_i,\Sigma\setminus\Theta)$$ of that strategy then we would have a contradiction. Once the game reaches the specification $$S$$, Player II deems Player I to have played a first move $$y_i=(\gamma_i,\Theta)$$ in the auxiliary game that would have provoked a response of the form $$y_j=(\gamma_j,S)$$. Thereafter, suppose that he does not have a winning strategy for getting into $$\pi(V)$$. Then Player I has a winning strategy $$\rho$$ for getting into $$\pi(V)^c$$. She can convert this into a winning strategy in the auxiliary game for getting into $$\pi^{-1}(\pi(V)^c)$$ given the first two moves, in a similar way to the way discussed above: if Player II plays a specification in $$S$$, then she responds with a specification in $$S$$. Otherwise, she reacts as $$\rho$$ dictates to the specifications outside $$S$$. This is a contradiction, since Player II has a winning strategy in the auxiliary game for getting into $$V$$, and $$\pi^{-1}(\pi(V)^c)\subset V^c$$. !!Conclusion It looks as though this attempt has worked, though it would be good at some point to check the proof above very carefully. !Which sets are simplified as a result of this lift, and how? If we look at the value of $$y_n$$, then we know which $$S\in\Sigma$$ has been declared. So this lift turns $$A$$ into a basic set under the following rather special set of circumstances. Let $$\Sigma$$ be the unavoidable set of specification sets. For every sequence $$x\in X$$, let $$\Sigma(x)$$ be the set of $$S\in\Sigma$$ that are compatible with $$x$$, and for every specification set $$S$$, let $$X(S)$$ be the set of sequences that obey all the specifications in $$S$$. Then $$\pi^{-1}(A)$$ is basic if for every $$x\in X$$, either $$X(S)\subset A$$ for every $$S\in\Sigma(x)$$ or $$X(S)\cap A=\emptyset$$ for every $$S\in\Sigma(x)$$. Let me check that. Suppose that the condition holds. Then let $$\Delta$$ be the set of all $$(\gamma_n,S)$$ such that $$S\in\Sigma$$ and $$X(S)\subset A$$. I claim that $$\pi^{-1}(A)=\{y:y_n\in\Delta\}$$. Indeed, let $$y_n=(\gamma_n,S)$$. Then $$\pi(y)\in X(S)$$. By definition, $$y_n\in\Delta$$ if and only if $$X(S)\subset A$$. Moreover, by hypothesis if $$X(S)\not\subset A$$, then $$X(S)\cap A=\emptyset$$. Therefore, $$y_n\in\Delta$$ if and only if $$\pi(y)\in A$$, as claimed. Unfortunately, this is a rather hard condition to satisfy. Even if $$A$$ is as simple a set as $$\{x\in X:x_1=\gamma_1,x_2=\gamma_2\}$$, the only way of making an //unavoidable// set of specifications that will determine whether a sequence belongs to $$A$$ is to make an unavoidable set of specifications, each of which includes specifications of the first two coordinates. Since one can specify the first two coordinates last, there seems to be little choice but to make $$\Sigma$$ the set of complete specifications of all the coordinates. That appears to take us back to the trivial lift, which is what we were trying to get away from. !!Are some sets simplified even if they aren't turned into basic sets? Let's take the example where $$\Sigma$$ is the set of all specification sets of size 2 (so one coordinate is specified for each player). Given a set $$A\subset X$$, what can we say about $$\pi^{-1}(A)$$? If $$S$$ is a specification of size 2 that happens to imply that a sequence belongs to $$A$$, then any $$y$$ with a coordinate of the form $$(\gamma_j,S)$$ will belong to $$\pi^{-1}(A)$$. Similarly, if $$S$$ is a specification that implies that a sequence does not belong to $$A$$, then any $$y$$ with a coordinate of the form $$(\gamma_j,S)$$ will belong to $$\pi^{-1}(A)^c$$. Suppose that $$A$$ is a 2-open set, meaning that for every $$x\in A$$ there exists a specification of two of its coordinates that is sufficient to imply that a sequence belongs to $$A$$. Let $$\Theta$$ be the set of all specifications of two coordinates such that $$X(S)\subset A$$. Our hypothesis is that $$\bigcup_{S\in\Theta}X(S)=A$$. Then every $$y\in Y$$ with a coordinate of the form $$(\gamma_j,S)$$ with $$S\in\Theta$$ maps into $$A$$. Moreover, every $$x\in A$$ is the image of such a $$y$$. So we have found a 1-open subset $$U\subset\pi^{-1}(A)$$ such that $$\pi(U)=A$$. That is not at all the same as saying that $$\pi^{-1}(A)$$ is 1-open, but perhaps it is an observation that is worth having made. For example, perhaps we should lower our sights when trying to say what property we are looking for from our Ramsey lifts. Instead of asking for the inverse image of $$A$$ to be simple, perhaps we should ask for simple sets $$U$$ and $$V$$ such that $$\pi(U)=A$$ and $$\pi(V)=A^c$$. Could that give us a distinguishing property? !!A second drawback with this method of lifting Before we get too excited about that possibility, we must face up to another drawback. A problem we face is that any unavoidable set $$\Sigma$$ is going to be quite large. Even if it consists of specifications of just two coordinates, the number of such specifications is comparable to the square of the alphabet size. So iterating lifts of this kind rapidly leads to alphabets of doubly exponential size. !Is there an example not of the above form? I'm particularly interested to have a general way of constructing a Ramsey lift $$\pi:Y\to X$$, given a complexity structure $$X\subset\Gamma^n$$, where the alphabet size of $$Y$$ is at most $$C^n$$ times the alphabet size of $$X$$. Since I am making no assumptions about the size of $$\Gamma$$, it is completely forbidden to allow the alphabet for $$Y$$ to contain all possible specifications of some coordinate of $$X$$. I have a vague thought about this that I would like to test. Suppose we know that $$X$$ is already a lift of $$\{0,1\}^n$$. Then we have a partition of $$X$$ into $$2^n$$ sets, and ultimately what interests us about any $$x\in X$$ is which cell of that partition it belongs to. What I'd like to know is whether we can do anything like the lift above, except that instead of specifying coordinates exactly, we specify merely whether they map to 0 or 1 when projected down to $$\{0,1\}^n$$. Rather than say what I mean in the abstract, let me write down a lift of this kind and see whether I can prove that it is Ramsey. I've tried something like this before, and I think the answer was no. But I'd like to try again. To keep things simple, I'll go for the extreme case where the unavoidable set $$\Sigma$$ is as big as possible: it consists of all sequences. However, Player I does not get to declare an //arbitrary// """I-winning""" subset of $$\Sigma$$ any more. This time she must declare a """I-winning""" subset of $$\{0,1\}^n$$ and take its inverse image. To put it another way, Player I chooses a """I-winning""" subset $$\Theta\subset\Sigma$$, which has the property that whether or not $$x\in\Theta$$ depends only on $$\pi(x)$$. Then Player II chooses not a sequence in this set but the inverse image of a sequence in $$\{0,1\}^n$$. Let me now define things a little more formally. I am given a complexity structure $$X\subset\Gamma^n$$ and a map $$\pi:X\to\{0,1\}^n$$ that obeys the condition that $$\pi(x)_i$$ depends on $$x_i$$ only. As usual, $$m=n/2$$. I now define $$Y$$ to be the set of sequences $$y=(y_1,\dots,y_n$$ with the following properties. #Exactly one $$y_i$$ with $$i\leq m$$ takes the form $$(\gamma_i,\pi^{-1}(W))$$ for some """I-winning""" subset $$W\subset\{0,1\}^n$$. #All other $$y_i$$ with $$i\leq m$$ are of the form $$\gamma_i$$. #There is a set $$R$$ of the form $$\pi^{-1}(\{w\})$$ with $$w\in W$$ such that every $$y_j$$ with $$j>m$$ is a pair $$(\gamma_j,R)$$. #$$(\gamma_1,\dots,\gamma_n)\in R$$. If $$y$$ is as above, then $$\phi(y)=(\gamma_1,\dots,\gamma_n)$$. One could think of this as something like a quotient of the trivial lift. !!Is this a Ramsey lift? The answer is almost certainly no, but let's try to understand what goes wrong. Let $$V$$ be a """I-winning""" subset of $$Y$$ and let $$\sigma$$ be a winning strategy for Player I to get into $$V$$. Let the first move of $$\sigma$$ for Player I be the specification $$y_i=(\gamma_i,\pi^{-1}(W))$$, where $$W$$ is a """I-winning""" subset of $$\{0,1\}^n$$. (This is one case: as in the proof above, Player I's strategy does not have to start this way.) Note that $$\pi^{-1}(W)$$ is a """I-winning""" subset of $$X$$, since otherwise $$\pi^{-1}(W)^c$$ would be a """II-winning""" subset of $$X$$, from which it would follow that $$\pi(\pi^{-1}(W)^c)$$, and hence $$W^c$$, was a """II-winning""" subset of $$\{0,1\}^n$$, which it isn't. I don't know whether this is relevant. Note also that for every possible response $$y_j=(\gamma_j,\pi^{-1}(\{w\}))$$ by Player II to the specification $$y_i=(\gamma_i,\pi^{-1}(W))$$, Player I has a winning strategy for getting into $$V$$. OK, the problem is that in the game in $$X$$, Player I can guarantee to produce a sequence in $$\pi^{-1}(W)$$ and can guarantee to produce a sequence in $$\phi(V)$$ if both players agree to restrict themselves to $$\pi^{-1}(\{w\})$$ for any particular $$w\in W$$, but that does not imply that Player I can guarantee to produce a sequence in $$\phi(V)$$. It would be good to have a counterexample though. !!!Attempted counterexample Let's go for an extreme situation, where $$n=2$$. Let the """I-winning""" subset $$W$$ of $$\{0,1\}^2$$ consist of the two sequences 00 and 01. We need Player I to have a winning strategy for getting into a set $$V\subset X$$ if the game takes place inside $$\pi^{-1}(00)$$ and also if it takes place inside $$\pi^{-1}(01)$$ but we want the two winning strategies to be somehow incompatible. But that's easy to achieve. Let $$X=\{00,01,10,11\}^2$$ and let $$V$$ be the set $$\{(00,00), (00,01), (01,10), (01,11)\}$$. Define $$\pi:X\to\{0,1\}^2$$ by $$\pi(ab,cd)=(a,c)$$. Thus, $$\pi^{-1}(00)=\{(00,00),(00,01),(01,00),(01,01)\}$$. Player I's winning strategy inside that for getting into $$V$$ is to start with the move $$x_1=00$$. Similarly, Player I's winning strategy inside $$\pi^{-1}(01)$$ is to start with the move $$x_1=01$$. Also, Player I has a winning strategy for getting into $$\pi^{-1}(W)$$, which is to start with the move $$x_1=00$$. But Player I does not have a winning strategy for getting into $$V$$: if she starts with $$00$$ then Player II can counter with $$10$$ and if she starts with $$01$$ then Player II can counter with $$00$$. !!!Correction That doesn't quite work, because in $$Y$$ Player II has to declare not just a $$w\in W$$ but also a $$\gamma_j$$. I don't think that will change anything too radically, but I think it will make the counterexample I'm trying to find a bit more complicated. In particular, I think it will make it necessary to choose $$n\geq 4$$. So let me go for $$n=4$$. !!!Another try Let $$n=4$$, let $$X=\{00,01,10,11\}^4$$ and let (\pi(a_1b_1,a_2b_2,a_3b_3,a_4b_4)=(a_1,a_2,a_3,a_4)\). Let us take $$Z\subset X$$ to be the set of all sequences $$(a_1b_1,a_2b_2,a_3b_3,a_4b_4)$$ such that $$a_1=b_3$$ and $$a_2=b_4$$. Then Player II clearly has a winning strategy for getting into $$Z$$. I claim now that Player I has a winning strategy in the game in $$Y$$ for //not// getting into $$\phi^{-1}(Z)$$. She first plays the pair $$y_1=(0,X)$$. (Note that $$X=\pi^{-1}(\{0,1\}^4)$$ and is therefore the inverse image of a """I-winning""" subset of $$\{0,1\}^4$$.) Player II now has to choose $$y_3$$ or $$y_4$$. This means that if the eventual sequence in $$X$$ is $$(a_1b_1,a_2b_2,a_3b_3,a_4b_4)=(a_1,a_2,a_3,a_4)$$, then Player I has chosen $$a_1b_1$$, and Player II now chooses $$(b_1,b_2,b_3,b_4)$$ and one of $$a_3$$ and $$a_4$$. Whichever he chooses, Player I can now choose $$a_2b_2$$ in such a way that $$a_2\ne b_4$$, and therefore so that the eventual sequence in $$X$$ does not belong to $$Z$$. !Where does that leave us? We are still trying to find a non-trivial Ramsey lift that does not increase the size of the alphabet by very much. It seems to me that there is quite a good chance that such a thing does not exist. Therefore, I think it is worth trying to prove that. If I can't, then I may get a clue about how to find one, and if I can, then it will have a major effect on the whole project -- possibly delivering the killer blow. [[TryToProveTheOpposite|Must all non-trivial Ramsey lifts use large alphabets?]]
 It turns out that they do exist, at least when $$n=2$$. Given that, the next obvious question would appear to be whether in the case $$n=2$$ we can reduce the circuit complexity of a set using a lift that does not increase the size of the alphabet by too much. Here we face a dilemma that I have only very recently noticed. As things stand, I have defined the circuit complexity of a subset $$A$$ of a complexity structure $$X$$ as follows. It is the length of the shortest sequence $$A_1,\dots,A_m$$ such that $$A_m=A$$ and every $$A_i$$ is either a basic set or an intersection or union of two earlier sets in the sequence. But do I want this to be the definition, or do I want to allow only one basic set per coordinate? If I go for the second option then many sets will not be computable at all, but if I go for the first, then there are many potential ways of computing a set, which will make it hard to prove lower bounds for the size of an efficient lift. Indeed, it may explain why I am finding it hard to prove that trivial lifts can't simplify sets. The relevance here is that if we go for the first option (as I think we must), then the circuit complexity of a subset $$A\subset X$$ can be large even when $$n=2$$. A trivial upper bound in this case is $$|A|$$: we can write $$A$$ as $$\bigcup_{(x,y)\in A}\{(x,y)\}$$, and each set $$\{(x,y)\}$$ is the intersection of two basic sets. If we think of $$A$$ as a matrix, then a better upper bound is the rank of that matrix over $$\mathbb{F}_2$$ (up to a constant factor). If $$X\subset\Gamma^2$$, then this gives us a general upper bound of $$CN$$. So let's continue with the current definition of circuit complexity and ask the following question. Let $$X\subset\Gamma^2$$ be a two-dimensional complexity structure. Does there always exist a complexity structure $$Y\subset\Theta^2$$ and a Ramsey lift $$\pi:Y\to X$$ that simplifies some subsets of $$X$$, with $$|\Theta|\leq C|\Gamma|$$ for some constant $$C$$ that is independent of $$|\Gamma|$$? [[TryWeakerQuestion|When n=2, is it always possible to find an efficient Ramsey lift that simplifies some set?]]
 I have given a fairly complete answer to that question, but only because the question turned out to be less interesting than I had hoped. It occurs to me that another potentially useful weakening of the main question on this page is to ask whether there are interesting maps that preserve """I-winning""" sets but not necessarily """II-winning""" sets, or vice versa. [[TryWeakerQuestion|Are there interesting examples of lifts that preserve the winning sets of one player?]]  The title and subtitle of your space are visible to visitors and are also displayed in your browser's tabs. Click on the SiteTitle and SiteSubtitle tiddler links below to make changes. * [[SiteTitle]] * [[SiteSubtitle]] !!Parent page We are trying to determine [[whether trivial lifts can simplify sets|Can trivial lifts be used to simplify sets?]]. !Introduction Let $$X$$ be a complexity structure and let $$\pi:Y\to X$$ be a trivial lift. Let $$A$$ be a subset of $$X$$. Let $$B$$ and $$C$$ be basic subsets of $$Y$$ and suppose that $$B\cap C=\pi^{-1}(A)$$. Does it follow that $$A$$ is the intersection of two basic sets? !Attempt at proof As usual, let's take $$X\subset\Gamma^n$$ and $$Y\subset\Theta^n$$ and suppose that the map $$\pi$$ takes the form $$\pi(y_1,\dots,y_n)=(\phi(y_1),\dots,\phi(y_n))$$. Let $$i$$,$$j$$, $$\Delta_i$$ and $$\Delta_j$$ be such that $$B=\{y\in Y:y_i\in\Delta_i\}$$ and $$C=\{y\in Y:y_i\in\Delta_j\}$$. Let us also assume that $$\Delta_i$$ and $$\Delta_j$$ are minimal with these properties, since that seems to be a helpful assumption. Can we now write down a candidate pair of basic sets in $$X$$ that might intersect to give us $$A$$? There is certainly a pair of sets we can write down, but it seems a bit unlikely that they will work in general. Those sets are $$\{x\in X:x_i\in\phi(\Delta_i)\}$$ and $$\{x\in X:x_j\in\phi(\Delta_j)\}$$. We saw [[on this page|Can a trivial lift lift a non-basic set to a basic set?]] that these two sets are equal to $$\pi(B)$$ and $$\pi(C)$$. The problem is that $$\pi(B\cap C)$$ is not obviously equal to $$\pi(B)\cap\pi(C)$$. I'm assuming here that $$i\ne j$$, since otherwise our intersection of basic sets is a basic set and the result is easy. But if $$B$$ and $$C$$ are basic sets based on different coordinates, then they have a kind of "independence" that makes it harder to stop $$\pi(B\cap C)$$ from equalling $$\pi(B)\cap\pi(C)$$. I'm not claiming that they are always equal, but just that there is some hope that we can tinker with $$B$$ and $$C$$ so as to make them equal. For example, can we assume that $$\Delta_i$$ and $$\Delta_j$$ are minimal so as to give us the sets $$B$$ and $$C$$ but minimal so as to give us two basic sets that intersect to $$B\cap C$$? Let me try that. So I shall assume that if I remove any element from $$\Delta_i$$ or $$\Delta_j$$, then the result will be to remove elements from $$B\cap C=\{y\in Y:y_i\in\Delta_i,y_j\in\Delta_j\}$$. Does that imply that $$\pi(B\cap C)=\pi(B)\cap\pi(C)$$? To answer that, let $$y\in B$$ and $$z\in C$$ be such that $$\pi(y)=\pi(z)=x$$. We are asking whether there must necessarily exist $$w\in B\cap C$$ such that $$\pi(w)=x$$. Let $$y_i=\theta_i$$ and $$z_j=\theta_j$$. Let us apply the triviality conditon with $$K=\{i\}$$ and the specifications $$x_i=\phi(\theta_i)$$, $$y_i=\theta_i$$ and $$x_j=\phi(\theta_j)$$. That gives us $$w\in Y$$ such that $$w_i=\theta_i$$ and $$\phi(w_j)=\phi(\theta_j)$$. But I do not see that we can improve the second assertion to $$w_j=\theta_j$$. !Is the triviality condition weaker than I think? Consider the following example. Let $$X=\{0\}^2$$ (that is, it consists of the sequence $$(0,0)$$ and nothing else). Let $$Y\subset\{0,1\}^2$$ consist of the sequences $$(0,0)$$ and $$(1,1)$$. This appears to satisfy the triviality condition. (The map $$\pi$$ has no choice but to send everything to $$(0,0)$$.) Now let $$B=\{y\in Y:y_1=0\}$$ and $$C=\{y\in Y:y_2=1\}$$. Then $$B\cap C=\emptyset$$ but $$\pi(B)\cap\pi(C)=\{(0,0)\}$$. Actually, that example isn't convincing, because the sets used to define $$B$$ and $$C$$ are not minimal sets that yield $$B\cap C$$. !If we look at the case n=2, can we rephrase the question as one about bipartite graphs? The answer is surely yes, since a subset of $$\Gamma^2$$ can be identified a bipartite graph. So the real point at issue is what the question looks like once reformulated in these terms. We have one bipartite graph $$G$$ whose vertex sets are copies of $$\Gamma$$ and another one $$H$$ whose vertex sets are copies of $$\Theta$$. We also have a map $$\phi:\Theta\to\Gamma$$ with the property that if $$(\theta_1,\theta_2)$$ is an edge of $$H$$, then $$(\phi(\theta_1),\phi(\theta_2)$$ is an edge of $$G$$. The triviality condition tells us two things. Let $$x$$ be a non-isolated vertex of $$G$$. Then there exists a non-isolated vertex $$z$$ of $$H$$ that maps to $$x$$. And now, if we fix such a $$z$$ and pick any neighbour $$y$$ of $$x$$, there is a neighbour $$w$$ of $$z$$ that maps to $$y$$. We now want to know whether if the inverse image of some subgraph $$G'$$ of $$G$$ is an induced subgraph of $$H$$, then $$G'$$ is an induced subgraph of $$G$$. (At least, that's what I think we want to know.) There is a simple criterion for a subgraph $$G'$$ of $$G$$ to be induced. It is that if $$xy$$ and $$x'y'$$ are two disjoint edges of $$G'$$ and $$xy'$$ is an edge of $$G$$, then $$xy'$$ is an edge of $$G'$$. So let us suppose that that does not happen and see whether we can deduce that the inverse image of $$G'$$ is not induced in $$H$$. First, let us pick, as we know we can, edges $$zw$$ and $$z'w'$$ of $$H$$ such that $$\phi(z)=x$$, $$\phi(w)=y$$, $$\phi(z')=x'$$ and $$\phi(w')=y'$$. (We get these using the triviality condition.) We are assuming that $$xy'$$ is an edge of $$G$$ but not of $$G'$$. Let me start this again. I'll pick $$w$$ such that $$\phi(w)=y$$. Next, I'll use the triviality condition to find $$z$$ such that $$zw\in H$$ and $$\phi(z)=x$$. Now I'll use the triviality condition to pick $$w'$$ such that $$zw'\in H$$ and $$\phi(w')=y'$$. Finally, I'll use the triviality condition to pick $$z'$$ such that $$z'w'\in H$$ and $$\phi(z')=x'$$. Then the image of the edge $$zw'$$ is $$xy'$$, which does not belong to $$G'$$, so $$zw'$$ belongs to $$H$$ but not to the inverse image of $$G'$$, so the inverse image of $$G'$$ is not induced in $$H$$. !Does that solve the general case as well? I think it does. Suppose that $$A$$ is not of the form $$\{x\in X:x_i\in\Delta_i,x_j\in\Delta_j\}$$. Then in particular if we define $$\Delta_i=\{\gamma:\exists x\in A\ x_i=\gamma\}$$, and similarly for $$\Delta_j$$, we do not get $$A$$. This means that there must exist $$x,x'\in A$$ and $$y\in X\setminus A$$ such that $$y_i=x_i$$ and $$y_j=x_j'$$. Now let us use the triviality property to find $$z\in Y$$ such that $$\phi(z_j)=x_j$$, $$\phi(z_i)=x_i$$ and $$\pi(z)=x$$. Next, let us use the triviality property to find $$w\in Y$$ such that $$\phi(w_i)=x_i$$, $$\phi(w_j)=x_j'$$ and $$\pi(w)=y$$. Finally, let us use the triviality property to find $$z'\in Y$$ such that $$\phi(z_i')=x_i'$$, $$\phi(z_j')=x_j'$$ and $$\pi(z')=x'$$. This has given us $$z,z'\in\pi^{-1}(A)$$ and $$w\in Y\setminus\pi^{-1}(A)$$ such that $$w_i=z_i$$ and $$w_j=z_j'$$. It follows that $$\pi^{-1}(A)$$ is not an intersection of basic sets, one based on restricting the $$i$$th coordinate and the other based on restricting the $$j$$th coordinate.  The vast majority of mathematical ideas I have had have never seen the light of day. For most of them, that is probably a good thing. However, some ideas feel as though they could be useful, if presented in as clear a way as possible. So I am experimenting with a hierarchical organization of the ideas that make up some of my failed (or as I prefer to think of it, not yet successful) proof attempts. I hope that in due course others may be able to add further ideas. The organization of the site is described in much more detail [[here|Organizing an open maths notebook]]. !Problems discussed so far [[An approach to the P versus NP problem|Does P=NP?]] (see also the [[sitemap|A sitemap for the P versus NP notebook]]) I have tried and failed to prove many more theorems than I have tried and succeeded in proving. But some of my failures feel more like not-yet-successes -- that is, ideas that could conceivably work, if combined with suitable further ideas. This site is an attempt to present my thoughts so far about certain problems, in the hope that others may be encouraged to help me pursue them. !!Parent page We want to find an efficient lift for a set of low circuit complexity and have [[reduced the problem to something simpler looking|What do we need in order to show that sets of low circuit complexity can be efficiently lifted?]]. !Introduction We are given a complexity structure $$X$$ and a 2-basic subset $$C=A\cap B$$ of $$X$$. We would like to find a very efficient Ramsey lift $$\pi:Y\to X$$ such that $$\pi^{-1}(C)$$ is 1-basic (or 1-open would suffice). !Some possible rough plans of attack We could look at the construction of [[the trivial lift that turns all sets in to 1-open sets|Is there an easy Ramsey lifting that makes all sets simple?]] and try to see whether we can vastly simplify it, given that our aim of turning just one 2-basic set into a 1-open set is so much more modest. Alternatively, we could try to imitate as closely as possible Martin's proof that a closed set can be lifted to an open set. Yet another possibility would be to try a process of """GuessAndAdjust""". For example, we could find a fairly simple lift without worrying about the Ramsey property and then try to adjust it until it has the Ramsey property. I think I'll go for """GuessAndAdjust""", saving up the first two techniques to use if I need a little help with the adjustment. !Preliminary considerations Let $$A=\{x:x_i\in\Delta_i\}$$ and let $$B=\{x:x_j\in\Delta_j\}$$. We want a lift $$\pi:Y\to X$$ such that $$\pi^{-1}(A\cap B)$$ is a 1-basic set. I don't want to break symmetry, especially if both $$i$$ and $$j$$ belong to the same half of $$\{1,2,\dots,n\}$$, so I'm tempted to try to make $$\pi^{-1}(A\cap B)$$ a basic set in two different ways: one via a restriction on the $$i$$th coordinate and the other via a restriction on the $$j$$th coordinate. What I need, in that case, is to ensure that if you know either the $$i$$th coordinate or the $$j$$th coordinate of $$y\in Y$$, then you know whether $$\pi(y)\in A\cap B$$. Since the one condition we place on $$\pi$$ for it to count as a map between complexity structures is that the $$r$$th coordinate of $$pi(y)$$ should depend only on the $$r$$th coordinate of $$y$$, the $$i$$th coordinate already tells us whether $$\pi(y)\in A$$ and the $$j$$th coordinate already tells us whether $$\pi(y)\in B$$. So the non-obvious thing we need is for the $$i$$th coordinate of $$y$$ to tell us whether $$\pi(y)\in B$$ and the $$j$$th coordinate of $$y$$ to tell us whether $$\pi(y)\in A$$. !A first attempt A crudely obvious way of doing this is to add "extra information" to the $$i$$th and $$j$$th coordinates. That is, we let $$Y$$ be the set of sequences $$y=(y_1,\dots,y_n)$$ with the following properties. #$$y_i$$ is a pair of the form $$(x_i,\epsilon_i)$$ with $$\epsilon_i\in\{0,1\}$$. #$$y_j$$ is a pair of the form $$(x_j,\epsilon_j)$$ with $$\epsilon_j\in\{0,1\}$$. #Every other $$y_r$$ is of the form $$x_r$$. #The sequence $$x=(x_1,\dots,x_n)$$ belongs to $$X$$. #$$x\in B$$ if and only if $$\epsilon_i=1$$. #$$x\in A$$ if and only if $$\epsilon_j=1$$. The map $$\pi$$ is the obvious one: it takes $$y$$ to $$x$$. !!Is that a Ramsey lift? Since I haven't thought at all about the game, I am expecting the answer to be a resounding no. Assuming it is, then the aim will be to try to do something slightly cleverer, but still with only a very small amount of "extra information", so that the alphabet does not do anything worse than increase in size by a constant factor. All I can think of now is to try to prove that it //is// a Ramsey lift and wait to get stuck. So let $$W$$ be a """I-winning""" subset of $$Y$$. What could stop $$\pi(W)$$ being a """I-winning""" subset of $$X$$? I think I've seen an instant problem. Suppose that $$i$$ is in the first half of $$\{1,2,\dots,n\}$$ and that $$j$$ is in the second half. Suppose also that none of the sets $$A\cap B,A^c\cap B,A\cap B^c,A^c\cap B^c$$ is empty. Then Player I certainly does not have a winning strategy for the set $$A\cap B$$ in $$X$$: whatever she does, Player II can specify $$x_j$$ in such a way that it does not belong to $$\Delta_j$$. But Player I //does// have a winning strategy for $$\pi^{-1}(A\cap B)$$: as her first move she can specify $$y_i=(x_i,1)$$ for some $$x_i\in\Delta_i$$. !How can we rescue the attempt? The problem is now a little clearer. If we put in too much "extra information", then it gives Player I control over $$\pi^{-1}(A\cap B)$$ that she did not have over $$A\cap B$$. An immediate thought about that is that if $$i$$ is in the first half and $$j$$ is in the second half, then the extra information that guarantees that the point belongs to $$\pi^{-1}(A\cap B)$$ should apply to the $$j$$th coordinate only. That way, we do not give Player I a winning strategy for a set that should not be """I-winning""". !A second attempt I'm still taking $$A=\{x:x_i\in\Delta_i\}$$ and $$B=\{x:x_j\in\Delta_j\}$$. For the moment I'm going to look just at the case where $$i$$ belongs to the first half and $$j$$ belongs to the second half, which feels like the interesting case. This time, let $$Y$$ be the set of sequences $$y=(y_1,\dots,y_n)$$ with the following properties. #$$y_j$$ is a pair of the form $$(x_j,\epsilon_j)$$ with $$\epsilon_j\in\{0,1\}$$. #Every other $$y_r$$ is of the form $$x_r$$. #The sequence $$x=(x_1,\dots,x_n)$$ belongs to $$X$$. #$$x\in A$$ if and only if $$\epsilon_j=1$$. As before, the map $$\pi$$ takes $$y$$ to $$x$$. !!Is that a Ramsey lift? Suppose that Player I has a winning strategy $$\sigma$$ in $$Y$$ for a set $$W$$. I'd like to try to define a winning strategy for Player I in $$X$$ for $$\pi(W)$$. A natural starting point is that if the play so far has not involved either the coordinate $$i$$ or the coordinate $$j$$, then Player I should simply pretend that the game is taking place in $$Y$$ and do whatever $$\sigma$$ dictates. The potential trouble arrives if Player II specifies $$x_j$$ in the game in $$X$$. Then in the "auxiliary" game in $$Y$$, we have to decide whether Player II has played $$(x_j,1)$$ or $$(x_j,0)$$. In the first case, the eventual sequence will be obliged to have $$x_i\in\Delta_i$$ and in the second case it will be obliged to have $$x_i\notin\Delta_i$$. Actually, I don't see the problem (and this worries me a bit). It looks to me as though Player I can play in $$X$$ as follows. She regards each move of Player II as though it is a move in $$Y$$, by simply interpreting it that way, except that if Player II specifies $$x_j$$ then Player I interprets it as playing the move $$(x_j,1)$$ in $$Y$$. Since $$\sigma$$ is a winning strategy for $$W$$, this will result in a sequence in $$W$$ in the auxiliary game, and hence a sequence in $$\pi(W)$$ in the "real" game. //Added later: the above reasoning is wrong. In the auxiliary game, Player I is helped, after Player II has played $$(x_j,1)$$, by Player II's implicit promise that he will play in a way that is consistent with ending up in $$A$$. Back in the real game, Player II makes no such promise, so it is not necessarily possible for Player I to follow $$\sigma$$ for the rest of the game. The rest of this page is therefore based on an incorrect observation. However, some of the questions that arise at the bottom of the page are worth asking. Indeed, one of them led to my noticing that the observation was incorrect.// That was too easy: it showed that if Player I has a winning strategy for $$W$$, then she has a winning strategy for $$\pi(W)$$ with the additional property that she can determine whether or not the resulting sequence ends up in $$A$$. On grounds of cosmic balance, I think that that level of control is likely to result in Player II having //insufficient// control when we consider his winning strategies. So let's suppose, then, that $$\tau$$ is a winning strategy for Player II for $$W$$. As above, the basic idea is to pretend that the game is taking place in $$Y$$ and do what $$\tau$$ tells him to do. The potential trouble comes when $$\tau$$ tells him to specify $$y_j$$. This specification will be of the form $$(x_j,1)$$ or $$(x_j,0)$$. Which should Player II consider himself to have played in $$Y$$? If he decides to play in $$X$$ as though he had played $$(x_j,1)$$, and Player I has not yet specified $$x_i$$, then Player I could mess things up by choosing an $$x_i$$ that does not belong to $$\Delta_i$$. There doesn't seem to be anything stopping her from doing that. !!What now? We want to find a way to give Player II more control. In principle, this might well be possible, since Player I has too much control. So we want a way to make $$Y$$ in some sense "harder for Player I", whatever that might mean. (Actually, it should mean that in some way Player I has reduced options and Player II has increased options.) Let me try to say that more precisely. What alerted us to a potential difficulty was that for Player I it was in some sense strictly easier to win the game in $$X$$ with payoff set $$\pi(W)$$ than it was to win the game in $$Y$$ with payoff set $$W$$. We need to think about how it might be possible to do a lift in such a way that this phenomenon does not happen. It's not obvious how to do this, but as I said at the beginning of this page, I have some useful techniques in reserve to help me. I think it's time to try to understand why the problem I am having did not get in the way of [[the trivial lift defined earlier|Is there an easy Ramsey lifting that makes all sets simple?]]. Here's how I defined $$Y$$ and $$\pi$$. $$Y$$ consists of all sequences $$y=(y_1,\dots,y_n)$$ with the following properties. #For exactly one $$i$$ between 1 and $$n/2$$, we have $$y_i=\sigma$$, where $$\sigma$$ is a """Player-I""" strategy for $$X$$ such that the first move consists of a specification of $$x_i$$. #For exactly one $$j$$ between $$n/2+1$$ and $$n$$, we have $$y_j=x$$, where $$x$$ is an element of $$X$$ that could arise during a run of the game with Player I playing with the strategy $$\sigma$$ and Player II responding with a specification of $$x_j$$. #$$y_r=x_r$$ for every $$r$$ not equal to either $$i$$ or $$j$$. The map $$\pi$$ takes a sequence $$y$$ as just described to the sequence $$x$$. The question is, how can we cut down the size of $$Y$$ if we don't need the $$j$$th coordinate to determine the entire sequence $$x$$, but just to determine whether $$x_i\in\Delta_i$$? It seems to me that we still want to make the "extra information" at $$y_j$$ be the information of whether $$x_i\in\Delta_i$$, and that what we need to change is what Player I does. Player I must also commit herself to at least something. The trouble is, the only thing I can think of that Player I could commit herself to is whether $$x_i$$ will belong to $$\Delta_i$$. But it's not clear what that even means, other than simply playing $$x_i$$. I'm now starting to think that I need to take $$k=2$$ rather than $$k=1$$. That way, both players get a chance to influence the outcome. That raises three questions. In the tree case, it was possible to write down some variants of the trivial lift that dictated what happened for the first few moves. (For details, see the section "First observation" of [[this page|Can games with low-complexity payoff sets be lifted to not much larger games with payoff sets that are closed and open?]].) Is there any equivalent of that for complexity structures? [[TryWeakerQuestion|Is there an equivalent of the small Ramsey lifts that there are for trees?]] Can I make precise my hunch that $$k=1$$ won't work? [[EvaluateApproach|Is there any reason to think that it is not possible to lift 2-basic sets to 1-basic sets efficiently?]] Can I find a lift that converts 4-basic sets into 2-basic sets?
 I've got a bit stuck with the above approaches, so it's time to try to bring in Martin's proof. But how should that be done? [[LookForSomethingMoreSpecific|Can we find a lift that is modelled on Martin's lift from closed games to open games?]]
 I've realized that lifting 2-basic sets to 1-basic sets is //not// going to be easy -- unless everything is easy. Here is the reason. Let $$A=\{x\in X:x_i\in\Delta_i\}$$ and $$B=\{x\in X:x_j\in\Delta_j\}$$. Suppose that we can Ramsey lift $$A\cap B$$ to a subset of a complexity structure $$Y$$ of the form $$\{y\in Y:y_j\in\Theta_j\}$$, and can do it efficiently. Then we can do a further lift to ensure that $$A\cap B^c$$ is lifted to a set of the same form. Taking the union of the two sets, we find that $$A$$ has been lifted to a set of that form as well. But then we can lift $$\{0,1\}^n$$ in such a way that all basic sets defined in terms of one of the first $$n/2$$ coordinates become basic sets defined in terms of the $$j$$th coordinate. But once we've got that, then we've also got it for all Boolean combinations. So all sets that depend just on the first $$n/2$$ coordinates have been turned into basic sets that depend just on the $$j$$th coordinate. So we've managed to find an efficient Ramsey lift that works for far too large a class of sets. I don't think we can wriggle out of this by saying that the complexity comes when you mix sets that depend on the first $$n/2$$ coordinates and sets that depend on the last $$n/2$$ coordinates. That would require us to show that while efficient lifts as described above exist, they do not exist if $$i>n/2$$. !Is this a disaster? I don't think so. The reason is that if we really want to imitate Martin's proof, then our aim should be to lift closed sets to open sets. Martin doesn't do that by lifting the //components// of the closed sets to simpler components. Therefore, it is not too surprising if we have come unstuck when trying to do that.

   A //strategic subtree// $$S$$ //for Player I// of a tree $$T$$ is a subtree that contains the root and has the following additional properties. *If $$s$$ is a vertex in $$S$$ of even distance from the root, then $$s$$ has exactly one successor in $$S$$. *If $$s$$ is a vertex in $$S$$ of odd distance from the root, then every successor of $$s$$ in $$T$$ is a successor of $$s$$ in $$S$$. A strategic subtree for Player II is defined in a similar way but with "odd" and "even" interchanged. For more details, see [[A brief primer on Martin's Borel determinacy theorem]].   !!Parent page We are trying to [[assess the prospects for the shrinking-neighbourhoods game|Is the shrinking neighbourhoods game likely to work for our purposes?]]. !Introduction We would like to find an efficient Ramsey lift for the parity function, since if such lifts cannot in general be found for functions of polynomial circuit complexity, the parity function is a good candidate for a counterexample. !First attempt I've thought about this offline for a bit and come up with the following suggestion. I will take $$Y$$ to be the collection of all sequences $$((x_1,\epsilon),x_2,\dots,x_{n-1},(x_n,\eta))$$, where each $$x_i$$ is 0 or 1, $$\epsilon$$ is the parity of the first $$n/2$$ of the $$x_i$$, and $$\eta$$ is the parity of the last $$n/2$$ of the $$x_i$$. Given such a sequence, its image under $$\pi$$ is $$(x_1,x_2,\dots,x_n)$$. !!Is this a Ramsey lift? Let $$W$$ be a winning set for Player I in $$Y$$ and let $$\sigma$$ be a winning strategy for Player I for getting into $$W$$. Must Player I have a winning strategy in $$\{0,1\}^n$$ for getting into $$\pi(W)$$? I think the answer ought to be no. The rough reason for that is that in the auxiliary game, Player II commits himself to the eventual parity as soon as he decides on $$x_n$$, which Player I ought to be able to exploit to achieve properties of the eventual sequence that cannot normally be ensured. What happens if Player I plays the auxiliary game as $$\sigma$$ dictates and projects to the ordinary game? Everything is fine until Player II chooses $$x_n$$. At that point, Player I has to decide whether to play as though Player II has played $$(x_n,0)$$ or $$(x_n,1)$$ in the auxiliary game. What if $$\sigma$$ dictates completely different play in the two situations? What makes it hard to convert this thought into a counterexample is that Player I is not obliged to play moves in the auxiliary game in the order that they are played in the real game. Let $$W$$ be a subset of $$Y$$ and let us try to describe $$\pi(W)$$. We can partition $$W$$ into four parts, $$W_{00},W_{01},W_{10}$$ and $$W_{11}$$. The set $$W_{\epsilon\eta}$$ consists of the sequences of the form $$((x_1,\epsilon),x_2,\dots,x_{n-1},(x_n,\eta))$$. Then $$\pi(W_{\epsilon,\eta})$$ consists of those sequences in $$\pi(W)$$ for which the parity of the first $$n/2$$ bits is $$\epsilon$$ and the parity of the last $$n/2$$ bits is $$\eta$$. What does that do for us? !!Why it is not a Ramsey lift I've got it now. Let $$V\subset\{0,1\}^n$$ be the set of sequences $$x$$ such that $$x_i=x_{i+n/2}$$ for every $$i\leq n/2$$. Clearly, Player II has a winning strategy for obtaining a sequence in $$V$$. I claim that Player I has a winning strategy in the auxiliary game for obtaining a sequence in $$\pi^{-1}(V)^c$$. This contradicts the Ramsey property, since Player I does not have a winning strategy for obtaining a sequence in $$\pi(\pi^{-1}(V)^c)$$, as this is a subset of $$V^c$$. Player I's strategy for $$\pi^{-1}(V)^c$$ is the following. She begins by playing $$x_{n/2}=0$$. If Player II does anything other than declaring $$y_n$$, then he must choose $$x_j$$ for some $$j<n$$, to which Player I can counter by choosing $$x_{j-n/2}$$ to be different. But if he declares $$y_n$$, then he must say not only what $$x_n$$ is but also what the total parity $$\eta$$ of his bits is. Then Player I can choose $$y_1=(x_1,\epsilon)$$ in such a way that $$\epsilon\ne\eta$$. Since the parities of the bits they choose are now committed to being different, Player II cannot make the bits correspond in the way that is required by $$\pi^{-1}(V)$$. !Can this attempt be rescued? The argument just given uses what is probably quite a useful technique, which is to consider very small winning sets in the real game and to try to show that their inverse images are not winning sets in the auxiliary game. It would be interesting at this point to see whether we can generalize the above counterexample to show that the parity function cannot be Ramsey lifted to a basic set in a not much larger complexity structure. !Modification of first attempt Before I try that, however, I need to try a small tweak to that first attempt, since I don't immediately see a reason for it not to work. Let the sequences in $$Y$$ take the same form $$((x_1,\epsilon),x_2,\dots,x_{n-1},(x_n,\eta))$$, but this time let $$\epsilon$$ equal the parity of the first $$n/2$$ bits, while $$\eta$$ equals the parity of //all// the bits. The winning set that became a non-winning set in the previous example does not work here, since Player II has more control over the total parity. I don't immediately see what to do here, so let me consider what ought to be a simpler game, where Player II declares $$\eta$$ but Player I does not have to declare $$\epsilon$$. That ought to make things easier for Player I in the auxiliary game. Here is a heuristic argument that that is not a Ramsey lift. Let $$V$$ be a random subset of $$\{0,1\}^n$$ where each element is chosen independently with probablity $$p$$, and $$p$$ is chosen in such a way that the probability that Player II has a winning strategy for getting into $$V$$ is 1/2. And suppose that as it happens Player II does have a winning strategy for getting into $$V$$. Now let us think about what happens with $$\pi^{-1}(V)$$. Equivalently, let us think whether Player II can win if he is forced to say what the eventual parity will be at the moment he declares $$x_n$$. Because of the way that $$V$$ is constructed, I would expect Player II to have very little flexibility about his strategy. In particular, I would expect that with probability at least 10% he would no longer have a winning strategy if he was forced to delay specifying $$x_n$$ until the last 10% of moves. But if he specifies $$x_n$$ before the last 10% of moves, then he has to specify the parity, which reduces his target set to half its previous size. (OK, it doesn't reduce it to a random set of half the size, but it still noticeably reduces the target.) So it seems likely that with reasonable probability he can't win in this situation. So I am guessing that a suitably chosen random set will demonstrate that this is not a Ramsey lift. ''//Open Task: prove this rigorously.//'' [''//Task completed://'' Jason Dyer has constructed an example that demonstrates this. [[ClarifyQuestion|A proof that a certain lift is not Ramsey]] ] It's not completely clear that this sort of approach would show that the slightly more complicated game is not a Ramsey lift, because with that game Player I and Player II are operating under rather similar constraints. But perhaps there is a non-negligible probability that Player I will not be under pressure to play $$x_1$$ until late in the game, whereas Player II will be under pressure to play $$x_n$$ quite early on. In fact, we ought to be able to permute the ground set in order to ensure this. ''//Open Task: prove this rigorously.//'' What about the more symmetric game, where the sequences are of the form $$((x_1,\epsilon),\dots,(x_m,\epsilon),(x_{m+1},\eta),\dots,(x_n,\eta))$$? So both players commit themselves to their parities as soon as they make their first moves. ''//Open Task: decide whether this is a Ramsey lift.//'' [''//Task completed://'' there is now a counterexample for that problem as well. [[ClarifyQuestion|Another lift that is not Ramsey]].] Yet another variant that might be sensible is sequences where exactly one $$y_i$$ with $$i\leq m$$ takes the form $$(x_i,\epsilon)$$ (but that $$i$$ can be different for different sequences) with all the rest of the form $$x_i$$, but all the $$x_i$$ with $$i>m$$ of the form $$(x_i,\eta)$$. ''//Open Task: decide whether this is a Ramsey lift.//'' [''//Task completed://'' This one is obviously not Ramsey, since the set of all sequences of odd parity is """II-winning""" in the original game but """I-winning""" here. (The proof of the latter statement is that Player I can avoid declaring $$\eta$$ on her first move and can then make sure that the parity of her contribution is equal to $$\eta$$.)] !Are we in a position to prove anything general? Let's consider the following situation. We have a lift $$\pi:Y\to\{0,1\}^n$$, where the elements of $$Y$$ take the form $$(x_1,u),\dots,(x_m,u),(x_{m+1},v),\dots,(x_n,v))$$ with $$u\in U$$ and $$v\in V$$. By that I mean that $$Y$$ is a subset of the set of all such elements. The image of a sequence of that form is the sequence $$(x_1,\dots,x_n)$$. Suppose that every $$v$$ determines the parity of $$x$$. That is, for any given $$v$$, the images of sequences in $$Y$$ that use that $$v$$ all have the same parity. Does that place a significant lower bound on the size of the alphabet of $$Y$$? Consider the following class of """I-winning""" sets in the original game. The set $$\{m+1,\dots,n\}$$ is partitioned into subsets $$X_1,\dots,X_r$$ of size at least 2, and $$W$$ is the set of all sequences $$x\in\{0,1\}^n$$ such that either the restriction of $$x$$ to some $$X_j$$ is non-constant or the parity of $$x$$ is odd. Such a set $$W$$ is """I-winning""" because if Player II ensures that the restriction of $$x$$ to each $$X_j$$ is constant, then when he has made $$m-1$$ moves, Player I knows what his remaining move must be and can therefore ensure that the parity of $$x$$ will end up odd. On the other hand, it looks quite hard for $$\pi^{-1}(W)$$ to be a """I-winning""" set, since if $$v$$ determines the parity of $$x$$, then Player II may be able to give himself a significant boost by choosing $$v$$ so as to ensure that the parity of $$x$$ is odd. That remark doesn't prove anything much, but it tells us that if Player II is in a position to control the parity of $$x$$, then the choice of $$v$$ should not leave him with a winning strategy for ensuring that $$x$$ is constant on all the $$X_j$$. What's more that needs to be true whatever the partition is. Since in the original game it is very easy for Player II to make sure that $$x$$ is constant on all the $$X_j$$, that suggests that for each $$v$$ the game will have to be considerably restricted, which should in turn imply that there have to be a lot of different $$v$$. !Can we make that last thought precise? Maybe we can't, because there is in fact quite an efficient way to make sure that a sequence $$x$$ is not constant on every single set $$X_j$$. We can do it by picking a set $$Z$$ that intersects each $$X_j$$ in a non-empty subset of even size and insisting that the parity of $$x$$ restricted to $$Z$$ is odd. This shows that a set of size at most $$2^m$$ is enough "extra information" to achieve this purpose. !A simple but important observation Consider the following lift. Let $$X\subset\Gamma^n$$ be a complexity structure and let $$\mathcal{W}$$ be a set of """I-winning""" subsets of $$X$$. Define $$Y$$ to be the set of all sequences of the form $$(y_1,\dots,y_n)$$ with the following properties. #For exactly one $$i\leq m$$, $$y_i$$ is of the form $$(\gamma_i,W)$$, where $$W\in\mathcal{W}$$ and the move $$x_i=\gamma_i$$ is the first move of some winning strategy for getting into $$W$$. #For all other $$i\leq m$$, $$y_i=\gamma_i$$ for some $$\gamma_i\in\Gamma$$. #There exists $$x\in W$$ such that for every $$i>m$$, $$y_i$$ takes the form $$(\gamma_i,x$$. #$$x_i=\gamma_i$$ for every $$i$$. The map $$\pi:Y\to X$$ is the obvious one: it takes a sequence of the above form to $$x$$. If $$W\in\mathcal{W}$$, then Player I has an obvious winning strategy for getting into $$\pi^{-1}(W)$$. She simply chooses a strategy $$\sigma$$ for getting into $$W$$ and plays the initial move $$y_i=(\gamma_i,W)$$, where $$x_i=\gamma_i$$ is the initial move of $$\sigma$$. If $$V$$ is a """II-winning""" set, then Player II has a winning strategy for getting into $$V$$. If Player I begins with the move $$y_i=(\gamma_i,W)$$, then $$W\cap\{x\in X:x_i=\gamma_i\}$$ is a """I-winning""" set (since it is part of the definition of $$Y$$ that the move $$x_i=\gamma_i$$ is the first move of some winning strategy for getting into $$W$$). It therefore has a non-empty intersection with $$V$$, so Player II can choose $$x$$ in that intersection and declare some coordinate of $$x$$. If Player I begins with a move of the form $$y_i=\gamma_i$$, then there exists $$x\in X$$ such that $$x_i=\gamma_i$$, or else $$V$$ would clearly not be """II-winning""". So Player II can choose such an $$x$$ and declare some coordinate of $$x$$. This is a tiny generalization of the argument given [[at the end of this page|Is there an easy Ramsey lifting that makes all sets simple?]]. What it shows is that if all we want to do is ensure that every """I-winning""" set //of a certain kind// is preserved by a lift, then we can do that by multiplying the alphabet size by the number of minimal winning sets of that kind plus the number of points in $$X$$. Why did I describe this observation as important? Because it places constraints on how any lower-bound argument could look. Suppose I try to argue that there cannot be an efficient Ramsey lift by saying that if a lift uses a small alphabet then there must be a winning set of such-and-such a kind that is not preserved by the lift. If there are not too many winning sets of that kind, then the proof is doomed to fail. For instance, if I want to prove a doubly exponential lower bound but my class of """I-winning""" sets has size at most $$n!$$, then I am in trouble. Now let us look at what I have been trying to do in this page and its descendants. [[I showed here|Another lift that is not Ramsey]] that a certain lift that simplifies the parity function is not Ramsey. I did that by considering """I-winning""" sets of a particular form: where there is a partition of Player II's coordinates, and Player II must ensure that $$x$$ is constant on all cells of that partition, while also making $$x$$ have even parity. A little further up this page, I then ran into trouble when I tried to draw a general conclusion from this class of """I-winning""" sets. The observation I have just made is that that trouble was inevitable: there are no more than $$n^n$$ partitions of the coordinates, so we are not going to get a better bound than that if we look only at this class of """I-winning""" sets.  /% Hello, If you choose to change this GettingStarted tiddler, you may wish to add the following to your new content if you expect you space to be included: <<< ---- Hello, ''This ~GettingStarted tiddler has been customized.'' If you want to see the original system tiddler just click the following link: GettingStarted@system-info at system-info. <<< %/ Welcome to your brand new [[TiddlySpace|http://docs.tiddlyspace.com/TiddlySpace]]. You're almost ready to go, there are just a couple of things left to do. !Customise your space Go to [[SpaceSettings]] to finish customising your space. When you're done, come back here (just scroll up). Don't worry though, this will still be open when you've finished. !Further Customisation The [[ServerSettings]] tiddler is used to provide the following space configuration options: #index: The value is the name of a tiddler that will be presented when loading the space. For example, when set to Hello for the space hello.tiddlyspace.com, navigating to that URL will present the Hello tiddler. #editor: The name of an [[editor application|http://docs.tiddlyspace.com/Example%20Tiddler%20Editors]] to edit tiddlers with. Applications are [[included spaces|http://docs.tiddlyspace.com/How%20do%20I%20include%2Fexclude%20spaces%3F]] To edit these options, click [[here|ServerSettings]] to open the [[ServerSettings]] tiddler then click on the edit button (the pencil icon). Then add the options you wish to set and then click on the save button (the tick icon). An example [[ServerSettings]] tiddler: {{{ index: HelloThere editor: /edit#{tiddler} }}} The additional text after /edit allows a tiddler to be opened in edit mode e.g: {{{http://hello.tiddlyspace.com/edit#MyTiddler}}} !!See Also * [[ServerSettings shadow tiddler|http://docs.tiddlyspace.com/ServerSettings%20shadow%20tiddler]] * [[Choosing a non-TiddlyWiki Default Application for your Space|http://docs.tiddlyspace.com/Choosing%20a%20non-TiddlyWiki%20Default%20Application%20for%20your%20Space]] !Finished customising? You can [[Start writing]] some [[tiddlers|http://docs.tiddlyspace.com/Tiddler]]. If you're not done tweaking yet though, you can always [[Customise this space|SpaceSettings]] a bit more. You can also [[access and read other tiddlers in various ways|http://docs.tiddlyspace.com/Viewing%20Tiddlers]]. !Administration If you'd like to change your password or create another space, visit "Your Account" from the [[Universal Backstage|http://docs.tiddlyspace.com/UniversalBackstage]] (the blue dot in the upper right of the page). If you'd like to add a member or [[include a space|http://docs.tiddlyspace.com/How%20do%20I%20include%2Fexclude%20spaces%3F]] visit "This Space" from the [[Universal Backstage|http://docs.tiddlyspace.com/UniversalBackstage]]. You can have as many spaces as you like and each space can have as many members as you or your group need. !Stuck? If you're stuck, and would like some help, please visit the [[help|http://help.tiddlyspace.com]] space, which can point you in the right direction. !!Parent page I have been thinking about [[what a "strange" simplicity property could conceivably be like|What could a "strange" simplicity property conceivably be like?]]. !Introduction Here are the main messages that I take away from my consideration of this question so far. #The natural proofs barrier rules out properties of polynomial circuit complexity, which I think of loosely as properties that do not involve any second-order quantification. #Rudich's extension of the natural proofs barrier tells us that if we use only properties that involve a single second-order quantification -- that is, properties in NP or """co-NP""" -- then there will have to be a jump from a tiny NP property to a """co-NP""" property that applies to almost all functions. This sounds suspiciously like a trivial reformulation of the original problem. #I do not have a convincing argument against properties that involve two quantifiers -- that is, $$\Sigma_2$$ properties and $$\Pi_2$$ properties -- but I do not entirely rule out that one might exist. #I have a slightly clearer idea than I used to about what might count as an "interesting" consequence of low circuit complexity. !So what am I looking for now? Given that $$\Pi_2$$ and $$\Sigma_2$$ properties are the simplest kind that appear to have a chance of working (though the argument against $$\Sigma_1$$ and $$\Pi_1$$ properties is highly non-rigorous, since I don't have a precise argument that rules out a "jump" from a tiny $$\Sigma_1$$ property to a tiny-complement $$\Pi_1$$ property), I want to focus on those. So my aim is this. I want to define an auxiliary class of second-order objects. Using a small circuit $$C$$ that computes a function $$f$$, and given an object $$A$$ in the auxiliary class, I want to show that it is possible to construct an object $$B$$ such that some relationship holds between $$A,B$$ and $$f$$. And I want the proof that this is possible to be non-trivial. As I said above, I have a clearer idea now of what constitutes a non-trivial consequence of low circuit complexity. It is laid out in detail at the end of [[this page|What counts as an "interesting" consequence of low circuit complexity?]]. The basic idea is that the property that follows from low circuit complexity should not be obtained by weakening one ingredient of the definition of low circuit complexity (such as allowing bigger circuits, allowing something more general than a circuit, or insisting only that the output is correct for at least 2/3 of all inputs). !What is the main problem I face? The difficulty is that I am searching for something tiny -- an actually useful $$\Sigma_2$$ property -- in a vast space -- the space of all potentially useful $$\Sigma_2$$ properties. I have to find some way of making the task more tractable. There are two natural ways of doing this. One is to """LookForSomethingMoreSpecific""", by which I mean to add extra conditions on the property I am trying to find, so as to reduce the size of the space I am looking inside. The other is to """LookForSomethingLessSpecific""", by which I mean to increase the size of the set of properties that would count as a success. One way of looking for something less specific is to be satisfied with //any// non-trivial consequence of low circuit complexity. We sort of know that the consequence has to be non-trivial to be useful, so why not concentrate on the non-triviality first, and think about usefulness only when we get some feel for how to deduce non-trivial consequences. If we want to look for something more specific, we still have to decide what properties to add. One technique is to try to look for something that is as simple as is consistent with not obviously not existing. We have been engaged in that process already: $$\Sigma_2$$ and $$\Pi_2$$ properties are the simplest ones that don't have a serious flaw with them. I do not see any obvious way of making further simplicity assumptions. Other ways of adding properties are to add structure such as symmetry, or conditions such as maximality or minimality. I don't see any way of using these techniques either. That still leaves me with some problem-solving techniques. One is guess-and-adjust: that is, I try out a property $$P$$, and when it doesn't work, I use the failure as a way of adding properties that $$P$$ should satisfy. The problem with that strategy here is that the only properties I can think of are ones that follow trivially from low circuit complexity. That is, I can't see a way of making the initial guess. (Or perhaps one could say that the initial guess is a trivial consequence and I can't see how to adjust it.) Another is to attempt to use //analogy//. That is, I would like to find a different mathematical question where something is known, and then try to do something analogous for circuit complexity. !A well-known analogy with unfortunate limitations When trying to prove lower bounds for circuit complexity, it is tempting to think about an infinite version of the problem. There is a very natural candidate for what this might mean. Recall that a straight-line computation is a way of building up a set from basic sets using intersections, unions and complements. That sounds very like the definition of a Borel set -- which is a set that can be built out of basic sets using //countable// intersections and unions, and complements. Further encouragement comes from the fact that the natural analogue of NP sets, namely analytic sets, are known not to be Borel in general. In other words, "P$$\ne$$NP in the infinite world". Could we not somehow find a finite version of the argument that shows this, and thereby show that P$$\ne$$NP? This has been attempted, notably by Sipser, and it has not succeeded. The problem is that there are some quite strong //dis//analogies between the two situations. Here are a few of them. #The problem of determining whether an infinite bipartite graph contains a perfect matching is not Borel, but there is a polynomial-time algorithm for solving it for finite bipartite graphs. #The parity function has a simple polynomial-time algorithm, but there is no measurable function defined on the set of infinite 01-sequences that changes its value every time you change one bit of your infinite sequence. #The infinite Ramsey theorem implies that for every Borel set $$A$$ of infinite subsets of $$\mathbb{N}$$ there exists an infinite set $$X\subset\mathbb{N}$$ such that its infinite subsets either all belong to $$A$$ or all belong to $$A^c$$. In the finite setting, the collection of all sets of even size shows that we cannot hope for a conclusion like this. (So again it is the parity function that causes the trouble.) This does not make the analogy completely useless. However, it seems that the right analogue of a Borel set is a set defined by a circuit of polynomial size //and constant depth//. It is a well-known result in complexity theory that such circuits cannot compute the parity function. !Are there any other properties of Borel sets that might be worth thinking about? Well, there is one famous property they have, which is that of being //determined//. That is, if you have a Borel set $$A$$ and use it to define an infinite game where two players take turns giving the bits of an infinite sequence, then either the first player has a winning strategy for ensuring that the resulting sequence belongs to $$A$$ or the second player has a winning strategy for ensuring that it belongs to $$A^c$$. For a detailed discussion of Borel determinacy, see my series of blog posts that starts [[with this one|http://gowers.wordpress.com/2013/08/23/determinacy-of-borel-games-i/]]. Is it worth trying to find a finitary analogue of this result? That question deserves a new page. [[EvaluateApproach|Advantages and disadvantages of Borel determinacy as a potential analogue]].
 The conclusion of that page is that it //is// worth trying to find a finitary analogue. However, we must be on our guard because of the differences between Borel sets and sets of low circuit complexity. In particular, we must be aware the whole time of the danger that a simplicity property we come up with may fail to apply to the parity function, in which case it will be useless to us. (It might be of some mild interest to prove that functions computable with circuits of polynomial size and bounded depth give rise to games with particularly simple winning strategies, but it is not what we are really interested in.) So let us start the search for a useful finitary analogue of Martin's Borel determinacy theorem. [[LookForSomethingMoreSpecific|What might a finitary analogue of Martin's theorem look like?]]. To follow the discussion, it is not necessary to be familiar with all the details of Martin's proof. However, one does need to know a few things. If you don't, then I have written [[A brief primer on Martin's Borel determinacy theorem]]. A much more detailed account can be found in the series of blog posts mentioned above. !!Parent page We want to know [[how much extra information is needed to shift a basic set|How much extra information is needed to shift a basic set?]]. !Introduction We have formulated a slightly weaker question that should, if we can answer it, give us a significant insight into the original question. Roughly speaking, we want to know whether the amount of extra information has to be unbounded unless it is not genuine information. !A precise version of the question Let $$X$$ be a complexity structure and let $$\mathcal{X}$$ be a set of subsets of $$X$$. Suppose that a game is devised as follows. Let $$\{\mathcal{X}_u:u\in U\}$$ be a collection of subsets of $$\mathcal{X}$$. Then Player I chooses some $$u\in U$$, Player II chooses some $$V\in\mathcal{X}_u$$, and the players then play the shrinking-neighbourhoods game in $$V$$. If $$A$$ is a payoff set in $$X$$, then the payoff set in the new game is again $$A$$, in the sense that Player I wins if the eventual sequence belongs to $$A$$. And now the question: if the size of $$\mathcal{X}$$ is bounded, and if every set $$V\in\mathcal{X}$$ is a proper subset of $$X$$, is it possible for every """I-winning""" set in the old game to be a """I-winning""" set in the new game and every """II-winning""" set in the old game to be a """II-winning""" set in the new game? Since I want the answer to be no, I want to focus, at least to start with, on trying to find a proof that it is not possible. So for every $$n$$ and every $$N$$ I would like to find a complexity structure $$X\subset\Gamma^n$$ such that for every auxiliary game defined as above using a collection $$\mathcal{X}$$ of at most $$N$$ proper subsets of $$X$$ there is a winning set in the original game that is not a winning set for the same player in the auxiliary game. !Sanity check It occurs to me that there might be some tiresome example of a complexity structure $$X$$ and a point in $$X$$ that cannot be essential to any winning set. So there might be a proper subset $$V\subset X$$ such that for every winning set $$W$$, $$V\cap W$$ is a winning set for the same player. Actually, maybe it isn't problematic if such complexity structures exist, but it certainly will be problematic if every sufficiently large complexity structure contains "inessential" points. At any rate, the following question seems interesting. Let $$X$$ be a complexity structure. Does every point in $$X$$ belong to at least one minimal winning set? If $$X$$ has a transitive symmetry group, then the answer is trivially yes. So it's not the case that every sufficiently large complexity structure contains inessential points. But it would still be problematic if we had to deal with complexity structures with inessential points, and therefore worth thinking about the more general problem. So we are looking for "strange" examples. This question doesn't seem trivial, so I think it needs a new page. [[TryWeakerQuestion|Does every point belong to a minimal winning set?]]
 I have not managed to answer that question, so I think I'll restrict this page to a discussion of whether there is an efficient lift when the complexity structure is $$\{1,2,\dots,r\}^n$$. That is, can we find a Ramsey lift where the amount of extra information depends on $$n$$ only and not on $$r$$? Let me remind myself of the precise version of the question. Write $$[r]$$ for $$\{1,2,\dots,r\}$$. Suppose that $$\mathcal{X}$$ is a collection of proper subsets of $$[r]^n$$, and suppose that we define a game as follows. Player I chooses a subset $$\mathcal{X}_u$$ of $$\mathcal{X}$$ (for some $$u$$ in a set $$U$$ that indexes a collection of subsets of $$\mathcal{X}$$). Player II then chooses $$V\in\mathcal{X}_u$$. Then the shrinking-neighbourhoods game is played inside $$V$$. Suppose that $$|\mathcal{X}|$$ is bounded as a function of $$r$$ and $$r$$ is sufficiently large. Is it possible that whenever $$W\subset[r]^n$$ is a winning set, it remains a winning set for the same player in the new game? (That is, if a player can force the final sequence to belong to $$W$$ in the original game, then (s)he can do so in the new game as well.) I'll start by considering what happens when $$n=2$$. I'm not sure it's the same question as the ones I've already answered for $$n=2$$, so I'll try it and risk repeating myself. [[TryWeakerQuestion|If we add a bounded amount of information when n=2, then what happens?]]
 The answer is that we can't prove anything much without imposing a non-triviality condition of some kind, but a condition that does give rise to a reasonable result is to insist that after the extra information has been declared, the bipartite graph in which the game takes place (we can think of a subset of $$[r]^2$$ as a bipartite graph) has maximum degree $$r/2$$. If we ask for this, then $$k$$ has to be at least $$cr/\log r$$. So the question now is whether we can do something similar for larger $$n$$ and thereby obtain our first interesting lower bound for something resembling "lift complexity". I'll need a suitable generalization for the bound on the maximum degree. I think I'll go for the following. Let $$X=[r]^n$$. Call a subset $$V$$ of $$X$$ //small// if for every $$v\in V$$ and every $$i$$ the number of $$w\in V$$ such that $$w_i=v_i$$ is at most $$r^{n-1}/2$$. In other words, if we say that $$v$$ and $$w$$ are $$i$$-//neighbours// if $$v_i=w_i$$, then for every $$v\in V$$, at most half the $$i$$-neighbours of $$v$$ are in $$V$$. Now let's insist that $$\mathcal{X}$$ consists only of small sets. The modification of the original question that I'd like to think about is this. ''Question.'' If the size of $$\mathcal{X}$$ is bounded, and if every set $$V\in\mathcal{X}$$ is a small subset of $$X$$, is it possible for every """I-winning""" set in the old game to be a """I-winning""" set in the new game and every """II-winning""" set in the old game to be a """II-winning""" set in the new game? This is the same as the original question except that "proper subset" has been changed to "small subset". If we are trying to generalize the proof that worked when $$n=2$$, then the obvious first question to ask is this. Let $$V$$ be a small set. Then what proportion of minimal """I-winning""" sets in $$X$$ can be """I-winning""" sets when restricted to $$V$$? It occurs to me that it might be worth asking a more general question. Suppose that $$V$$ is a subset of $$X$$ such that the proportion of minimal """I-winning""" sets that remain """I-winning""" in $$V$$ is at least $$p$$. What can be said about $$V$$? If it is too difficult to analyse the uniform distribution on the set of all minimal """I-winning""" subsets of $$X$$, then an alternative is to pick some reasonably large set of minimal """I-winning""" subsets. Actually, this is easier for """II-winning""" subsets: one can choose a random permutation $$\phi$$ of $$[m]$$ and random functions $$f_i:[r]\to[r]$$, one for each $$i\in [m]$$, and take the set of all $$x\in X$$ such that $$x_{m+\phi(i)}=f_i(x_i)$$ for $$i=1,2,\dots,m$$. So maybe it would be better to start with those. !Under what conditions does such a set remain """II-winning""" in $$V$$? Let me start with the simple example $$W=\{x\in X:x_{m+i}=x_i, i=1,2,\dots,m\}$$. Let $$V\subset X$$. Then for $$W\cap V$$ to be a """II-winning""" subset of $$V$$, what do we need? In $$X$$ the game is very "tight", in the sense that if Player I plays optimally, then Player II's moves are all forced. Player II's strategy is to respond to every declaration of the form $$x_i=h$$ by the corresponding declaration $$x_{m+i}=h$$. If he ever declares anything else, then either he has already lost, or he has given Player I the opportunity to win at the next move. In $$V$$, however, this strategy may not be forced. Suppose that Player I begins with $$x_1=1$$ and Player II responds with $$x_{m+2}=1$$. In $$X$$, Player I could play $$x_2=2$$ and Player II would lose. But in $$V$$ there may not be any sequences with $$x_1=x_{m+2}=1$$ and $$x_2\ne 1$$. It looks far too complicated to characterize those $$V$$ inside which $$W$$ remains a """II-winning""" set. Therefore, I think the best we can hope for is a necessary condition, or equivalently a sufficient condition for Player I to be able to win the game inside $$V$$. I want that condition to be very likely to occur. Here is what Player I would normally expect to be able to do. Typically, about half (at least) of all possible sequences in $$W$$ will fail to be in $$V$$. So a fairly obvious strategy is to pick such a sequence and declare its first $$m$$ coordinates. Then Player II would normally be forced to match those coordinates, except that that will eventually become impossible. For Player II not to be defeated by this strategy, he will have at some point to declare a coordinate $$x_{m+j}$$ that does not match the coordinate just declared by Player I. But that he can do only if it is not possible for Player I to choose $$x_j$$ to be not equal to $$x_{m+j}$$. That is, it is possible for Player II if the only extensions left are ones where $$x_j=x_{m+j}$$. This implies that of the extensions of the coordinates declared so far to points in $$X$$, the proportion that belong to $$V$$ is at most $$1/r$$. ''Open Task. Try to convert the above thoughts into a rigorous argument that the size of $$\mathcal{X}$$ must depend on $$r$$.'' !What about shifting basic sets? Let's try a different "smallness" condition on the extra information. Let $$[r]$$ be partitioned into two sets $$R_0$$ and $$R_1$$ of equal size, and let us insist that every $$V\in\mathcal{X}$$ is a subset of one of the two basic sets $$\{x\in X:x_n\in R_i\}$$. Can we argue in this situation that the proportion of the special minimal """II-winning""" sets discussed above that remain """II-winning""" inside $$V$$ is very small? Suppose that $$V\subset\{x\in X:x_n\in R_0\}$$. Let us look at winning sets $$W$$ of the special kind for which $$\phi(m)=n$$. (That is, the $$n$$th coordinate of points in $$W$$ has to be some function $$f_m$$ of the $$m$$th coordinate.) Player I has the option of declaring $$x_m$$ on her first move, so she can win if there exists a sequence $$x$$ in $$V$$ such that $$f_m(x_m)\notin R_0$$. Suppose that in $$V$$ there are $$t$$ possible values that $$x_m$$ can take. Then the probability, for a randomly chosen $$f_m$$, that the images of all these values lie in $$R_0$$ is $$2^{-t}$$. This gives us a similar argument to the one [[that we obtained when n=2|If we add a bounded amount of information when n=2, then what happens?]]. Since the set $$\{x\in X:x_m=h\}$$ is """I-winning""", there must exist at least one $$\mathcal{X}_u$$ such that every $$V\in\mathcal{X}_u$$ contains a sequence with $$x_m=h$$. But then if the number of $$u$$ is at most $$k$$, that implies that there exists $$u$$ and a set $$H$$ of size at least $$r/k$$ such that for every $$h\in H$$ and every $$V\in\mathcal{X}_u$$ there exists $$x\in V$$ with $$x_m=h$$. Since each such $$V$$ can help us to lift at most a proportion $$2^{-|H|}$$ of the special """II-winning""" sets to """II-winning""" sets, we get that $$|\mathcal{X}_u|$$ must be at least $$2^{r/k}$$. So the amount of extra information has to be at least $$\min\{k,2^{r/k}\}$$, which is at least $$cr/\log r$$. A site for writing up proof attempts in a structured way /*** |''Name''|TiddlySpacePublishingCommands| |''Version''|0.8.5| |''Status''|@@beta@@| |''Description''|toolbar commands for drafting and publishing| |''Author''|Jon Robson| |''Source''|http://github.com/TiddlySpace/tiddlyspace/raw/master/src/plugins/TiddlySpacePublishingCommands.js| |''CoreVersion''|2.6.1| |''Requires''|TiddlySpaceConfig TiddlySpaceFilters| !Usage Provides changeToPrivate, changeToPublic and saveDraft commands Provides TiddlySpacePublisher macro. {{{<<TiddlySpacePublisher type:private>>}}} make lots of private tiddlers public. {{{<<TiddlySpacePublisher type:public>>}}} make lots of public tiddlers public. !TODO * add public argument? !Code ***/ //{{{ (function() {

var tiddlyspace = config.extensions.tiddlyspace;
var originMacro = config.macros.tiddlerOrigin;

tiddlyspace.getTiddlerStatusType = function(tiddler) {
var exists = store.tiddlerExists(tiddler.title);
} else if(!exists) {
return "missing";
} else {
var types = ["private", "public"];
var type = "external";
for(var i = 0; i < types.length; i++) {
var t = types[i];
type = config.filterHelpers.is[t](tiddler) ? t : type;
}
if(config.filterHelpers.is.unsynced(tiddler)) {
type = type == "private" ? "unsyncedPrivate" : "unsyncedPublic";
}
return type;
}
};

var cmd = config.commands.publishTiddler = {
text: "make public",
tooltip: "Change this private tiddler into a public tiddler",
errorMsg: "Error publishing %0: %1",

isEnabled: function(tiddler) {
},
handler: function(ev, src, title) {
var tiddler = store.getTiddler(title);
if(tiddler) {
var newBag = cmd.toggleBag(tiddler.fields["server.bag"]);
this.moveTiddler(tiddler, {
title: tiddler.fields["publish.name"] || tiddler.title,
fields: { "server.bag": newBag }
});
}
},
toggleBag: function(bag, to) {
var newBag;
if(typeof bag != typeof "") {
var tiddler = bag;
bag = tiddler.fields["server.bag"];
}
if(bag.indexOf("_private") > -1) { // should make use of endsWith
to = to ? to : "public";
newBag = bag.replace("_private", "_" + to);
} else {
to = to ? to : "private";
newBag = bag.replace("_public", "_" + to);
}
return newBag;
},
copyTiddler: function(title, newTitle, newBag, callback) {
var original = store.getTiddler(title);
newTitle = newTitle ? newTitle : title;
var publish = function(original, callback) {
var tiddler = $.extend(new Tiddler(newTitle), original); tiddler.fields =$.extend({}, original.fields, {
"server.bag": newBag,
"server.workspace": "bags/%0".format(newBag),
"server.page.revision": "false"
});
delete tiddler.fields["server.title"];
tiddler.title = newTitle;
};
publish(original, callback);
},
moveTiddler: function(tiddler, newTiddler, callback) {
var info = {
copyContext: {},
deleteContext: {}
};
var _dirty = store.isDirty();
var newTitle = newTiddler.title;
var oldTitle = tiddler.title;
delete tiddler.fields["server.workspace"];
var oldBag = tiddler.fields["server.bag"];
var newBag = newTiddler.fields["server.bag"];
var newWorkspace = "bags/%0".format(newBag);
cmd.copyTiddler(oldTitle, newTitle, newBag, function(ctx) {
info.copyContext = ctx;
var context = {
tiddler: tiddler,
workspace: newWorkspace
};
tiddler.title = oldTitle; // for cases where a rename occurs
if(ctx.status) { // only do if a success
if(oldBag != newBag) {
info.deleteContext = ctx;
var el;
if(tiddler) {
tiddler.fields["server.workspace"] = newWorkspace;
tiddler.fields["server.bag"] = newBag;
}
el = el ? el : story.refreshTiddler(oldTitle, null, true);
if(oldTitle != newTitle) {
store.deleteTiddler(oldTitle);
store.notify(oldTitle, true);
}
if(el) {
story.displayTiddler(el, newTitle);
}
if(oldTitle != newTitle) {
story.closeTiddler(oldTitle);
}
if(callback) {
callback(info);
}
store.setDirty(_dirty);
});
} else {
if(callback) {
callback(info);
}
}
refreshDisplay();
}
});
}
};

var changeToPrivate = config.commands.changeToPrivate = {
text: "make private",
tooltip: "turn this public tiddler into a private tiddler",
isEnabled: function(tiddler) {
},
handler: function(event, src, title) {
var tiddler = store.getTiddler(title);
var newBag = cmd.toggleBag(tiddler, "private");
var newTiddler = { title: title, fields: { "server.bag": newBag }};
cmd.moveTiddler(tiddler, newTiddler);
}
};
config.commands.changeToPublic = cmd;

/* Save as draft command */
var saveDraftCmd = config.commands.saveDraft = {
text: "save draft",
tooltip: "Save as a private draft",
isEnabled: function(tiddler) {
return changeToPrivate.isEnabled(tiddler);
},
getDraftTitle: function(title) {
var draftTitle;
var draftNum = "";
while(!draftTitle) {
var suggestedTitle = "%0 [draft%1]".format(title, draftNum);
if(store.getTiddler(suggestedTitle)) {
draftNum = !draftNum ? 2 : draftNum + 1;
} else {
draftTitle = suggestedTitle;
}
}
return draftTitle;
},
createDraftTiddler: function(title, gatheredFields) {
var tiddler = store.getTiddler(title);
var draftTitle = saveDraftCmd.getDraftTitle(title);
var draftTiddler = new Tiddler(draftTitle);
if(tiddler) {
$.extend(true, draftTiddler, tiddler); } else {$.extend(draftTiddler.fields, config.defaultCustomFields);
}
for(var fieldName in gatheredFields) {
if(TiddlyWiki.isStandardField(fieldName)) {
draftTiddler[fieldName] = gatheredFields[fieldName];
} else {
draftTiddler.fields[fieldName] = gatheredFields[fieldName];
}
}
var privateBag = tiddlyspace.getCurrentBag("private");
var privateWorkspace = tiddlyspace.getCurrentWorkspace("private");
draftTiddler.title = draftTitle;
draftTiddler.fields["publish.name"] = title;
draftTiddler.fields["server.workspace"] = privateWorkspace;
draftTiddler.fields["server.bag"] = privateBag;
draftTiddler.fields["server.title"] = draftTitle;
draftTiddler.fields["server.page.revision"] = "false";
delete draftTiddler.fields["server.etag"];
return draftTiddler;
},
handler: function(ev, src, title) {
var tiddler = store.getTiddler(title); // original tiddler
var tidEl = story.getTiddler(title);
var uiFields = {};
story.gatherSaveFields(tidEl, uiFields);
var tid = saveDraftCmd.createDraftTiddler(title, uiFields);
tid = store.saveTiddler(tid.title, tid.title, tid.text, tid.modifier,
new Date(), tid.tags, tid.fields);
autoSaveChanges(null, [tid]);
story.closeTiddler(title);
story.displayTiddler(src, title);
story.displayTiddler(src, tid.title);
}
};

var macro = config.macros.TiddlySpacePublisher = {
locale: {
title: "Batch Publisher",
changeStatusLabel: "Make %0",
noTiddlersText: "No tiddlers to publish",
changeStatusPrompt: "Make all the selected tiddlers %0.",
description: "Change tiddlers from %0 to %1 in this space"
},

listViewTemplate: {
columns: [
{ name: "Selected", field: "Selected", rowName: "title", type: "Selector" },
{ name: "Tiddler", field: "tiddler", title: "Tiddler", type: "Tiddler" },
{ name: "Status", field: "status", title: "Status", type: "WikiText" }
],
rowClasses: []
},

changeStatus: function(tiddlers, status, callback) { // this is what is called when you click the publish button
var publicBag;
for(var i = 0; i < tiddlers.length; i++) {
var tiddler = tiddlers[i];
var newTiddler = {
title: tiddler.title,
fields: { "server.bag": cmd.toggleBag(tiddler, status) }
};
cmd.moveTiddler(tiddler, newTiddler, callback);
}
},
getMode: function(paramString) {
var params = paramString.parseParams("anon")[0];
var status = params.type ?
(["public", "private"].contains(params.type[0]) ? params.type[0] : "private") :
"private";
var newStatus = status == "public" ? "private" : "public";
return [status, newStatus];
},
handler: function(place, macroName, params, wikifier, paramString, tiddler) {
var wizard = new Wizard();
var locale = macro.locale;
var status = macro.getMode(paramString);
wizard.createWizard(place, locale.title);
'<input type="hidden" name="markList" />');
var markList = wizard.getElement("markList");
var listWrapper = $("
").addClass("batchPublisher"). attr("refresh", "macro").attr("macroName", macroName). attr("params", paramString)[0]; markList.parentNode.insertBefore(listWrapper, markList);$.data(listWrapper, "wizard", wizard);
macro.refresh(listWrapper);
},
getCheckedTiddlers: function(listWrapper, titlesOnly) {
var tiddlers = [];
$(".chkOptionInput[rowName]:checked", listWrapper).each(function(i, el) { var title =$(el).attr("rowName");
if(titlesOnly) {
tiddlers.push(title);
} else {
tiddlers.push(store.getTiddler(title));
}
});
return tiddlers;
},
refresh: function(listWrapper) {
var checked = macro.getCheckedTiddlers(listWrapper, true);
var paramString = $(listWrapper).empty().attr("params"); var wizard =$.data(listWrapper, "wizard");
var locale = macro.locale;
var params = paramString.parseParams("anon")[0];
var publishCandidates = [];
var status = macro.getMode(paramString);
var pubType = status[0];
var newPubType = status[1];
var tiddlers = params.filter ? store.filterTiddlers(params.filter[0]) :
store.filterTiddlers("[is[%0]]".format(pubType));
var enabled = [];
for(var i = 0; i < tiddlers.length; i++) {
var tiddler = tiddlers[i];
var title = tiddler.title;
if(!tiddler.tags.contains("excludePublisher") && title !== "SystemSettings") {
publishCandidates.push({ title: title, tiddler: tiddler, status: pubType});
}
if(checked.contains(title)) {
enabled.push("[rowname=%0]".format(title));
}
}

if(publishCandidates.length === 0) {
createTiddlyElement(listWrapper, "em", null, null, locale.noTiddlersText);
} else {
var listView = ListView.create(listWrapper, publishCandidates, macro.listViewTemplate);
wizard.setValue("listView", listView);
var btnHandler = function(ev) {
var tiddlers = macro.getCheckedTiddlers(listWrapper);
var callback = function(status) {
$(".batchPublisher").each(function(i, el) { macro.refresh(el); }); }; macro.changeStatus(tiddlers, newPubType, callback); }; wizard.setButtons([{ caption: locale.changeStatusLabel.format(newPubType), tooltip: locale.changeStatusPrompt.format(newPubType), onClick: btnHandler }]);$(enabled.join(",")).attr("checked", true); // retain what was checked before
}
}
};

})(jQuery);
//}}}
!Spaces
<<groupBy server.bag>>

!Private
<<list filter [is[private]]>>

!Public
<<list filter [is[public]]>>

!Drafts
<<list filter [is[draft]]>>
//{{{
config.filters.numbersort = function(results,match) {
var field = match[3];
results = results.sort(function(a, b) {
var val1 = a[field] || a.fields[field];
var val2 = b[field] || b.fields[field];
return parseFloat(val1, 10) < parseFloat(val2, 10) ? -1 : 1;
});
return results;
};
//}}}

/***
|''Name''|TiddlySpaceBackstage|
|''Version''|0.8.0|
|''Description''|Provides a TiddlySpace version of the backstage and a homeLink macro|
|''Status''|@@beta@@|
|''Contributors''|Jon Lister, Jon Robson, Colm Britton|
|''Source''|http://github.com/TiddlySpace/tiddlyspace/raw/master/src/plugins/TiddlySpaceBackstage.js|
|''Requires''|TiddlySpaceConfig ImageMacroPlugin TiddlySpaceViewTypes|
!StyleSheet
.tiddler .error.annotation .button{
display: inline-block;
}

#backstageArea {
z-index: 49;
color: white;
background-color: black;
background: -webkit-gradient(linear,left bottom,left top,color-stop(0, #222),color-stop(0.5, #333),color-stop(1, #555));
background: -moz-linear-gradient(center bottom,#222 0%, #333 50%, #555 100%);
height: 25px;
}

#backstageButton {
overflow: hidden;
}

#backstageButton #backstageShow,
#backstageButton #backstageHide {
margin: 0px;
}

#backstageButton #backstageShow:hover,
#backstageButton #backstageHide:hover {
background: none;
color: none;
}

#backstageButton img,
#backstageButton svg {
width: 24px;
height: 24px;
}

#messageArea {
top: 50px;
}

#backstageToolbar {
position: relative;
}

#backstageArea a {
margin-left: 0px;
color: white;
background: none;
}

#backstageArea a:hover {
background-color: white;
}

#backstage ol,
#backstage ul {
}

#backstageButton a {
margin: 0;
}

.backstagePanelBody ul {
margin: 5px;
}

#backstage #backstagePanel {
margin-left: 5%;
margin-right: 5%;
}

#backstageToolbar a {
position: relative;
}

#backstageArea a.backstageSelTab,
line-height: 25px;
color: #767676;
}

display: inline;
}

#backstageToolbar a span {
z-index: 2;
}

display: inline;
margin-left: 1em !important;
}

.backstagePanelBody .button {
display: inline-block;
margin-right: 10px;
}

.backstagePanelBody {
margin: 0 0 0 0.6em;
}

#backstage table {
margin: auto;
}

#backstage .wizard table {
border: 0px;
margin: 0;
}

border: 0px;
width: 78%;
font-size: 0.7em;
}

#backstage div li.listTitle {
font-weight: bold;
text-decoration: underline;
font-size: 1em;
background: #ccc;
width: 100%;
}

#backstage fieldset {
border: solid 1px [[ColorPalette::Background]];
}

#backstage .viewer table,#backstage table.twtable {
border: 0px;
}

#backstageToolbar img {
}

#backstage .wizard,
#backstage .wizardFooter {
background: none;
}

.viewer td, .viewer tr, .twtable td, .twtable tr {
border: 1px solid #eee;
}

#backstage .inlineList ul li {
background-color: [[ColorPalette::Background]];
border: solid 1px [[ColorPalette::TertiaryMid]];
display: block;
float: left;
list-style: none;
margin-right: 1em;
}

.backstageClear, .inlineList form {
clear: both;
display: block;
margin-top: 3em;
}

text-align: center;
}

span.chunkyButton {
display: inline-block;
margin: 0;
border: solid 2px #000;
background-color: #04b;
}

span.chunkyButton a.button, span.chunkyButton a:active.button {
white-space: nowrap;
font-weight: bold;
font-size: 1.8em;
color: #fff;
text-align: center;
margin: 0;
border-style: none;
display: block;
}

span.chunkyButton:hover {
background-color: #014;
}

span.chunkyButton a.button:hover {
border-style: none;
background: none;
color: #fff;
}

#backstage .unpluggedSpaceTab .wizard,
.unpluggedSpaceTab .wizard {
background: white;
border: 2px solid #CCC;
}

.syncKey .keyItem {
border: 1px solid black;
display: inline-block;
margin: 0.2em;
}

font-size: 2em;
font-weight: bold;
margin: 0.4em 0em -0.2em;
}

.unpluggedSpaceTab .putToServer,
.unpluggedSpaceTab .notChanged {
display: none;
}

margin: 0;
}

list-style: none;
}

.unsyncedChanges .unsyncedList {
display: block;
}

.unsyncedList {
display: none;
}
!Code
***/
//{{{
(function ($) { var name = "StyleSheet" + tiddler.title; config.shadowTiddlers[name] = "/*{{{*/\n%0\n/*}}}*/". format(store.getTiddlerText(tiddler.title + "##StyleSheet")); // this accesses the StyleSheet section of the current tiddler (the plugin that contains it) store.addNotification(name, refreshStyles); if (!config.extensions.tiddlyweb.status.tiddlyspace_version) { // unplugged config.extensions.tiddlyweb.status.tiddlyspace_version = "<unknown>"; config.extensions.tiddlyweb.status.server_host = { url:config.extensions.tiddlyweb.host }; // TiddlySpaceLinkPlugin expects this } var disabled_tasks_for_nonmembers = ["tiddlers", "plugins", "batch", "sync"]; var tweb = config.extensions.tiddlyweb; var tiddlyspace = config.extensions.tiddlyspace; var currentSpace = tiddlyspace.currentSpace.name; var imageMacro = config.macros.image; if (config.options.chkBackstage === undefined) { config.options.chkBackstage = false; } // Set up Backstage config.tasks = {}; config.tasks.status = { text:"status", tooltip:"TiddlySpace Info", content:"<<tiddler Backstage##Menu>>" }; config.tasks.tiddlers = { text:"tiddlers", tooltip:"tiddlers control panel", content:"<<tiddler Backstage##BackstageTiddlers>>" }; config.tasks.plugins = { text:"plugins", tooltip:"Manage installed plugins", content:"<<tiddler Backstage##Plugins>>" }; config.tasks.batch = { text:"batch", tooltip:"Batch manage public/private tiddlers", content:"<<tiddler Backstage##BatchOps>>" }; config.tasks.tweaks = { text:"tweaks", tooltip:"Tweak TiddlyWiki behaviors", content:"<<tiddler Backstage##Tweaks>>" }; config.tasks.exportTiddlers = { text:"import/export", tooltip:"Import/export tiddlers from/to a TiddlyWiki", content:"<<tiddler Backstage##ImportExport>>" }; config.tasks.sync = { text:"sync", tooltip:"Check Sync status", content:"<<tiddler Backstage##SpaceUnplugged>>" }; if (window.location.protocol === "file:") { config.unplugged = true; } config.backstageTasks = ["status", "tiddlers", "plugins", "batch", "tweaks", "exportTiddlers", "sync"]; config.messages.backstage.prompt = ""; // initialize state var _show = backstage.show; backstage.show = function () { // selectively hide backstage tasks and tabs based on user status var tasks =$("#backstageToolbar .backstageTask").show();
var bs = backstage.tiddlyspace;
if (!config.unplugged) {
tweb.getUserInfo(function (user) {
if (user.anon) {
}
});
config.messages.memberStatus = bs.locale.loggedout;
} else {
bs.locale.nonmember : bs.locale.member;
}
});
} else {
config.messages.memberStatus = bs.locale.unplugged;
}

// display backstage
return _show.apply(this, arguments);
};
}
});
}

var commonUrl = "/bags/common/tiddlers/%0";

backstage.tiddlyspace = {
locale:{
member:"You are a member of this space.",
nonmember:"You are not a member of this space.",
loggedout:"You are currently logged out of TiddlySpace.",
unplugged:"You are unplugged."
},
showButton:function () {
var showBtn = $("#backstageShow")[0]; var altText =$(showBtn).text();
$(showBtn).empty(); imageMacro.renderImage(showBtn, "backstage.svg", { altImage:commonUrl.format("backstage.png"), alt:altText}); }, hideButton:function () { var hideBtn =$("#backstageHide")[0];
var altText = $(hideBtn).text();$(hideBtn).empty();
imageMacro.renderImage(hideBtn, "close.svg",
{ altImage:commonUrl.format("close.png"), alt:altText, width:24, height:24 });
}
};

var _init = backstage.init;
backstage.init = function () {
_init.apply(this, arguments);
var init = function (user) {
var bs = backstage.tiddlyspace;
bs.showButton();
bs.hideButton();
};
tweb.getUserInfo(init);
};

var home = config.macros.homeLink = {
locale:{
},
handler:function (place) {
var container = $("").appendTo(place)[0]; tweb.getUserInfo(function (user) { if (!user.anon && user.name !== currentSpace) { createSpaceLink(container, user.name, null, home.locale.linkText); } }); } }; config.macros.exportSpace = { handler:function (place, macroName, params) { var filename = params[0] || "/tiddlers.wiki?download=%0.html".format(currentSpace);$('download').// XXX: i18n
attr("href", filename).appendTo(place);
}
};

}(jQuery));
//}}}
/***
|''Name''|RevisionsCommandPlugin|
|''Author''|FND|
|''Contributors''|Martin Budden|
|''Version''|0.3.3|
|''Status''|@@beta@@|
|''Source''|http://svn.tiddlywiki.org/Trunk/association/plugins/RevisionsCommandPlugin.js|
|''CodeRepository''|http://svn.tiddlywiki.org/Trunk/association/plugins/|
|''CoreVersion''|2.6.0|
|''Keywords''|serverSide|
!Usage
Extend [[ToolbarCommands]] with {{{revisions}}}.
!Revision History
!!v0.1 (2009-07-23)
* initial release (renamed from experimental ServerCommandsPlugin)
!!v0.2 (2010-03-04)
* suppressed wikification in diff view
!!v0.3 (2010-04-07)
* restored wikification in diff view
!To Do
* strip server.* fields from revision tiddlers
* resolve naming conflicts
* i18n, l10n
* code sanitizing
* documentation
!Code
***/
//{{{
(function($) { jQuery.twStylesheet(".diff { white-space: pre, font-family: monospace }", { id: "diff" }); var cmd = config.commands.revisions = { type: "popup", hideShadow: true, text: "revisions", tooltip: "display tiddler revisions", revTooltip: "", // TODO: populate dynamically? loadLabel: "loading...", loadTooltip: "loading revision list", selectLabel: "select", selectTooltip: "select revision for comparison", selectedLabel: "selected", compareLabel: "compare", linkLabel: "side-by-side view", revSuffix: " [rev. #%0]", diffSuffix: " [diff: #%0 #%1]", dateFormat: "YYYY-0MM-0DD 0hh:0mm", listError: "revisions could not be retrieved", handlePopup: function(popup, title) { title = this.stripSuffix("rev", title); title = this.stripSuffix("diff", title); var tiddler = store.getTiddler(title); var type = _getField("server.type", tiddler); var adaptor = new config.adaptors[type](); var limit = null; // TODO: customizable var context = { host: _getField("server.host", tiddler), workspace: _getField("server.workspace", tiddler) }; var loading = createTiddlyButton(popup, cmd.loadLabel, cmd.loadTooltip); var params = { popup: popup, loading: loading, origin: title }; adaptor.getTiddlerRevisionList(title, limit, context, params, this.displayRevisions); }, displayRevisions: function(context, userParams) { removeNode(userParams.loading); if(context.status) { var callback = function(ev) { var e = ev || window.event; var revision = resolveTarget(e).getAttribute("revision"); context.adaptor.getTiddlerRevision(tiddler.title, revision, context, userParams, cmd.displayTiddlerRevision); }; var table = createTiddlyElement(userParams.popup, "table"); for(var i = 0; i < context.revisions.length; i++) { var tiddler = context.revisions[i]; var row = createTiddlyElement(table, "tr"); var timestamp = tiddler.modified.formatString(cmd.dateFormat); var revision = tiddler.fields["server.page.revision"]; var cell = createTiddlyElement(row, "td"); createTiddlyButton(cell, timestamp, cmd.revTooltip, callback, null, null, null, { revision: revision }); cell = createTiddlyElement(row, "td", null, null, tiddler.modifier); cell = createTiddlyElement(row, "td"); createTiddlyButton(cell, cmd.selectLabel, cmd.selectTooltip, cmd.revisionSelected, null, null, null, { index:i, revision: revision, col: 2 }); cmd.context = context; // XXX: unsafe (singleton)!? } } else {$("
").text(cmd.listError).appendTo(userParams.popup);
}
},

revisionSelected: function(ev) {
var e = ev || window.event;
e.cancelBubble = true;
if(e.stopPropagation) {
e.stopPropagation();
}
var n = resolveTarget(e);
var index = n.getAttribute("index");
var col = n.getAttribute("col");
while(!index || !col) {
n = n.parentNode;
index = n.getAttribute("index");
col = n.getAttribute("col");
}
cmd.revision = n.getAttribute("revision");
var table = n.parentNode.parentNode.parentNode;
var rows = table.childNodes;
for(var i = 0; i < rows.length; i++) {
var c = rows[i].childNodes[col].firstChild;
if(i == index) {
if(c.textContent) {
c.textContent = cmd.selectedLabel;
} else {
c.text = cmd.selectedLabel;
}
} else {
if(c.textContent) {
c.textContent = cmd.compareLabel;
} else {
c.text = cmd.compareLabel;
}
c.onclick = cmd.compareSelected;
}
}
},

compareSelected: function(ev) {
var e = ev || window.event;
var n = resolveTarget(e);
var context = cmd.context;
context.rev1 = n.getAttribute("revision");
context.rev2 = cmd.revision;
context.tiddler = context.revisions[n.getAttribute("index")];
context.format = "unified";
context.userParams, cmd.displayTiddlerDiffs);
},

displayTiddlerDiffs: function(context, userParams) {
var tiddler = context.tiddler;
tiddler.title += cmd.diffSuffix.format([context.rev1, context.rev2]);
tiddler.text = "{{diff{\n" + context.diff + "\n}}}";
tiddler.tags = ["diff"];
tiddler.fields.doNotSave = "true"; // XXX: correct?
if(!store.getTiddler(tiddler.title)) {
}
var src = story.getTiddler(userParams.origin);
var tiddlerEl = story.displayTiddler(src, tiddler);
var uri = context.uri.replace("format=unified", "format=horizontal");
var link = $('').attr("href", uri).text(cmd.linkLabel);$(".viewer", tiddlerEl).prepend(link);
},

displayTiddlerRevision: function(context, userParams) {
var tiddler = context.tiddler;
tiddler.title += cmd.revSuffix.format([tiddler.fields["server.page.revision"]]);
tiddler.fields.doNotSave = "true"; // XXX: correct?
if(!store.getTiddler(tiddler.title)) {
}
var src = story.getTiddler(userParams.origin);
story.displayTiddler(src, tiddler);
},

stripSuffix: function(type, title) {
var str = cmd[type + "Suffix"];
var i = str.indexOf("%0");
i = title.indexOf(str.substr(0, i));
if(i != -1) {
title = title.substr(0, i);
}
return title;
}
};

var _getField = function(name, tiddler) {
return tiddler.fields[name] || config.defaultCustomFields[name];
};

})(jQuery);
//}}}
/***
|''Description''|Sanitisation for dynamically pulling tiddlers into your space and displaying them|
!Notes
Works both inside and outside TiddlyWiki. Uses the HTML Sanitizer provided by the Google Caja project
!Code
***/
//{{{
(function($) { var cleanURL = function(url) { var regexp = /^(?:http|https|mailto|ftp|irc|news):\/\//; return (regexp.test(url)) ? url : null; };$.sanitize = function(html) {
return html_sanitize(html, cleanURL);
};

/*
* HTML Sanitizer, provided by Google Caja
*/

* Licensed under the Apache Licence Version 2.0
* Autogenerated at Tue May 17 17:39:24 BST 2011
* @provides html4
*/var html4={};html4.atype={NONE:0,URI:1,URI_FRAGMENT:11,SCRIPT:2,STYLE:3,ID:4,IDREF:5,IDREFS:6,GLOBAL_NAME:7,LOCAL_NAME:8,CLASSES:9,FRAME_TARGET:10},html4.ATTRIBS={"*::class":9,"*::dir":0,"*::id":4,"*::lang":0,"*::onclick":2,"*::ondblclick":2,"*::onkeydown":2,"*::onkeypress":2,"*::onkeyup":2,"*::onload":2,"*::onmousedown":2,"*::onmousemove":2,"*::onmouseout":2,"*::onmouseover":2,"*::onmouseup":2,"*::style":3,"*::title":0,"a::accesskey":0,"a::coords":0,"a::href":1,"a::hreflang":0,"a::name":7,"a::onblur":2,"a::onfocus":2,"a::rel":0,"a::rev":0,"a::shape":0,"a::tabindex":0,"a::target":10,"a::type":0,"area::accesskey":0,"area::alt":0,"area::coords":0,"area::href":1,"area::nohref":0,"area::onblur":2,"area::onfocus":2,"area::shape":0,"area::tabindex":0,"area::target":10,"bdo::dir":0,"blockquote::cite":1,"br::clear":0,"button::accesskey":0,"button::disabled":0,"button::name":8,"button::onblur":2,"button::onfocus":2,"button::tabindex":0,"button::type":0,"button::value":0,"canvas::height":0,"canvas::width":0,"caption::align":0,"col::align":0,"col::char":0,"col::charoff":0,"col::span":0,"col::valign":0,"col::width":0,"colgroup::align":0,"colgroup::char":0,"colgroup::charoff":0,"colgroup::span":0,"colgroup::valign":0,"colgroup::width":0,"del::cite":1,"del::datetime":0,"dir::compact":0,"div::align":0,"dl::compact":0,"font::color":0,"font::face":0,"font::size":0,"form::accept":0,"form::action":1,"form::autocomplete":0,"form::enctype":0,"form::method":0,"form::name":7,"form::onreset":2,"form::onsubmit":2,"form::target":10,"h1::align":0,"h2::align":0,"h3::align":0,"h4::align":0,"h5::align":0,"h6::align":0,"hr::align":0,"hr::noshade":0,"hr::size":0,"hr::width":0,"iframe::align":0,"iframe::frameborder":0,"iframe::height":0,"iframe::marginheight":0,"iframe::marginwidth":0,"iframe::width":0,"img::align":0,"img::alt":0,"img::border":0,"img::height":0,"img::hspace":0,"img::ismap":0,"img::name":7,"img::src":1,"img::usemap":11,"img::vspace":0,"img::width":0,"input::accept":0,"input::accesskey":0,"input::align":0,"input::alt":0,"input::autocomplete":0,"input::checked":0,"input::disabled":0,"input::ismap":0,"input::maxlength":0,"input::name":8,"input::onblur":2,"input::onchange":2,"input::onfocus":2,"input::onselect":2,"input::readonly":0,"input::size":0,"input::src":1,"input::tabindex":0,"input::type":0,"input::usemap":11,"input::value":0,"ins::cite":1,"ins::datetime":0,"label::accesskey":0,"label::for":5,"label::onblur":2,"label::onfocus":2,"legend::accesskey":0,"legend::align":0,"li::type":0,"li::value":0,"map::name":7,"menu::compact":0,"ol::compact":0,"ol::start":0,"ol::type":0,"optgroup::disabled":0,"optgroup::label":0,"option::disabled":0,"option::label":0,"option::selected":0,"option::value":0,"p::align":0,"pre::width":0,"q::cite":1,"select::disabled":0,"select::multiple":0,"select::name":8,"select::onblur":2,"select::onchange":2,"select::onfocus":2,"select::size":0,"select::tabindex":0,"table::align":0,"table::bgcolor":0,"table::border":0,"table::cellpadding":0,"table::cellspacing":0,"table::frame":0,"table::rules":0,"table::summary":0,"table::width":0,"tbody::align":0,"tbody::char":0,"tbody::charoff":0,"tbody::valign":0,"td::abbr":0,"td::align":0,"td::axis":0,"td::bgcolor":0,"td::char":0,"td::charoff":0,"td::colspan":0,"td::headers":6,"td::height":0,"td::nowrap":0,"td::rowspan":0,"td::scope":0,"td::valign":0,"td::width":0,"textarea::accesskey":0,"textarea::cols":0,"textarea::disabled":0,"textarea::name":8,"textarea::onblur":2,"textarea::onchange":2,"textarea::onfocus":2,"textarea::onselect":2,"textarea::readonly":0,"textarea::rows":0,"textarea::tabindex":0,"tfoot::align":0,"tfoot::char":0,"tfoot::charoff":0,"tfoot::valign":0,"th::abbr":0,"th::align":0,"th::axis":0,"th::bgcolor":0,"th::char":0,"th::charoff":0,"th::colspan":0,"th::headers":6,"th::height":0,"th::nowrap":0,"th::rowspan":0,"th::scope":0,"th::valign":0,"th::width":0,"thead::align":0,"thead::char":0,"thead::charoff":0,"thead::valign":0,"tr::align":0,"tr::bgcolor":0,"tr::char":0,"tr::charoff":0,"tr::valign":0,"ul::compact":0,"ul::type":0},html4.eflags={OPTIONAL_ENDTAG:1,EMPTY:2,CDATA:4,RCDATA:8,UNSAFE:16,FOLDABLE:32,SCRIPT:64,STYLE:128},html4.ELEMENTS={a:0,abbr:0,acronym:0,address:0,applet:16,area:2,b:0,base:18,basefont:18,bdo:0,big:0,blockquote:0,body:49,br:2,button:0,canvas:0,caption:0,center:0,cite:0,code:0,col:2,colgroup:1,dd:1,del:0,dfn:0,dir:0,div:0,dl:0,dt:1,em:0,fieldset:0,font:0,form:0,frame:18,frameset:16,h1:0,h2:0,h3:0,h4:0,h5:0,h6:0,head:49,hr:2,html:49,i:0,iframe:4,img:2,input:2,ins:0,isindex:18,kbd:0,label:0,legend:0,li:1,link:18,map:0,menu:0,meta:18,nobr:0,noframes:20,noscript:20,object:16,ol:0,optgroup:0,option:1,p:1,param:18,pre:0,q:0,s:0,samp:0,script:84,select:0,small:0,span:0,strike:0,strong:0,style:148,sub:0,sup:0,table:0,tbody:1,td:1,textarea:8,tfoot:1,th:1,thead:1,title:24,tr:1,tt:0,u:0,ul:0,"var":0},html4.ueffects={NOT_LOADED:0,SAME_DOCUMENT:1,NEW_DOCUMENT:2},html4.URIEFFECTS={"a::href":2,"area::href":2,"blockquote::cite":0,"body::background":1,"del::cite":0,"form::action":2,"img::src":1,"input::src":1,"ins::cite":0,"q::cite":0},html4.ltypes={UNSANDBOXED:2,SANDBOXED:1,DATA:0},html4.LOADERTYPES={"a::href":2,"area::href":2,"blockquote::cite":2,"body::background":1,"del::cite":2,"form::action":2,"img::src":1,"input::src":1,"ins::cite":2,"q::cite":2};var html=function(a){function x(b,c,d){var e=[];w(function(b,e){for(var f=0;f<e.length;f+=2){var g=e[f],h=e[f+1],i=null,j;if((j=b+"::"+g,a.ATTRIBS.hasOwnProperty(j))||(j="*::"+g,a.ATTRIBS.hasOwnProperty(j)))i=a.ATTRIBS[j];if(i!==null)switch(i){case a.atype.NONE:break;case a.atype.SCRIPT:case a.atype.STYLE:h=null;break;case a.atype.ID:case a.atype.IDREF:case a.atype.IDREFS:case a.atype.GLOBAL_NAME:case a.atype.LOCAL_NAME:case a.atype.CLASSES:h=d?d(h):h;break;case a.atype.URI:h=c&&c(h);break;case a.atype.URI_FRAGMENT:h&&"#"===h.charAt(0)?(h=d?d(h):h,h&&(h="#"+h)):h=null;break;default:h=null}else h=null;e[f+1]=h}return e})(b,e);return e.join("")}function w(b){var c,d;return v({startDoc:function(a){c=[],d=!1},startTag:function(e,f,g){if(!d){if(!a.ELEMENTS.hasOwnProperty(e))return;var h=a.ELEMENTS[e];if(h&a.eflags.FOLDABLE)return;if(h&a.eflags.UNSAFE){d=!(h&a.eflags.EMPTY);return}f=b(e,f);if(f){h&a.eflags.EMPTY||c.push(e),g.push("<",e);for(var i=0,j=f.length;i<j;i+=2){var k=f[i],l=f[i+1];l!==null&&l!==void 0&&g.push(" ",k,'="',r(l),'"')}g.push(">")}}},endTag:function(b,e){if(d)d=!1;else{if(!a.ELEMENTS.hasOwnProperty(b))return;var f=a.ELEMENTS[b];if(!(f&(a.eflags.UNSAFE|a.eflags.EMPTY|a.eflags.FOLDABLE))){var g;if(f&a.eflags.OPTIONAL_ENDTAG)for(g=c.length;--g>=0;){var h=c[g];if(h===b)break;if(!(a.ELEMENTS[h]&a.eflags.OPTIONAL_ENDTAG))return}else for(g=c.length;--g>=0;)if(c[g]===b)break;if(g<0)return;for(var i=c.length;--i>g;){var h=c[i];a.ELEMENTS[h]&a.eflags.OPTIONAL_ENDTAG||e.push("</",h,">")}c.length=g,e.push("</",b,">")}}},pcdata:function(a,b){d||b.push(a)},rcdata:function(a,b){d||b.push(a)},cdata:function(a,b){d||b.push(a)},endDoc:function(a){for(var b=c.length;--b>=0;)a.push("</",c[b],">");c.length=0}})}function v(c){return function(d,e){d=String(d);var f=null,g=!1,h=[],j=void 0,l=void 0,m=void 0;c.startDoc&&c.startDoc(e);while(d){var n=d.match(g?t:u);d=d.substring(n[0].length);if(g){if(n[1]){var o=b(n[1]),p;if(n[2]){var q=n[3];switch(q.charCodeAt(0)){case 34:case 39:q=q.substring(1,q.length-1)}p=k(i(q))}else p=o;h.push(o,p)}else if(n[4]){l!==void 0&&(m?c.startTag&&c.startTag(j,h,e):c.endTag&&c.endTag(j,e));if(m&&l&(a.eflags.CDATA|a.eflags.RCDATA)){f===null?f=b(d):f=f.substring(f.length-d.length);var r=f.indexOf("</"+j);r<0&&(r=d.length),l&a.eflags.CDATA?c.cdata&&c.cdata(d.substring(0,r),e):c.rcdata&&c.rcdata(s(d.substring(0,r)),e),d=d.substring(r)}j=l=m=void 0,h.length=0,g=!1}}else if(n[1])c.pcdata&&c.pcdata(n[0],e);else if(n[3])m=!n[2],g=!0,j=b(n[3]),l=a.ELEMENTS.hasOwnProperty(j)?a.ELEMENTS[j]:void 0;else if(n[4])c.pcdata&&c.pcdata(n[4],e);else if(n[5]&&c.pcdata)switch(n[5]){case"<":c.pcdata("<",e);break;case">":c.pcdata(">",e);break;default:c.pcdata("&",e)}}c.endDoc&&c.endDoc(e)}}function s(a){return a.replace(m,"&$1").replace(n,"<").replace(o,">")}function r(a){return a.replace(l,"&").replace(n,"<").replace(o,">").replace(p,""").replace(q,"=")}function k(a){return a.replace(j,g)}function i(a){return a.replace(h,"")}function g(a,b){return f(b)}function f(a){a=b(a);if(c.hasOwnProperty(a))return c[a];var f=a.match(d);if(f)return String.fromCharCode(parseInt(f[1],10));if(!!(f=a.match(e)))return String.fromCharCode(parseInt(f[1],16));return""}var b;"script"==="SCRIPT".toLowerCase()?b=function(a){return a.toLowerCase()}:b=function(a){return a.replace(/[A-Z]/g,function(a){return String.fromCharCode(a.charCodeAt(0)|32)})};var c={lt:"<",gt:">",amp:"&",nbsp:"240",quot:'"',apos:"'"},d=/^#(\d+)$/,e=/^#x([0-9A-Fa-f]+)$/,h=/\0/g,j=/&(#\d+|#x[0-9A-Fa-f]+|\w+);/g,l=/&/g,m=/&([^a-z#]|#(?:[^0-9x]|x(?:[^0-9a-f]|$)|$)|$)/gi,n=/</g,o=/>/g,p=/\"/g,q=/\=/g,t=new RegExp("^\\s*(?:(?:([a-z][a-z-]*)(\\s*=\\s*(\"[^\"]*\"|'[^']*'|(?=[a-z][a-z-]*\\s*=)|[^>\"'\\s]*))?)|(/?>)|[\\s\\S][^a-z\\s>]*)","i"),u=new RegExp("^(?:&(\\#[0-9]+|\\#[x][0-9a-f]+|\\w+);||<!\\w[^>]*>|<\\?[^>*]*>|<(/)?([a-z][a-z0-9]*)|([^<&>]+)|([<&>]))","i");return{escapeAttrib:r,makeHtmlSanitizer:w,makeSaxParser:v,normalizeRCData:s,sanitize:x,unescapeEntities:k}}(html4),html_sanitize=html.sanitize

// stop here if we're not in TiddlyWiki
// XXX: is this the correct way of checking for TiddlyWiki?
if (!window.TiddlyWiki || !window.store || !store instanceof TiddlyWiki) {
return;
}

var tiddlyspace = config.extensions.tiddlyspace;

var _subWikify = Wikifier.prototype.subWikify;

var cleanedTitle = 'This section has been cleaned of any potentially harmful code';

var replaceFunctions = {
html: function(w) {
var sanitizedHTML, spanEl;
sanitizedHTML = $.sanitize(lookaheadMatch[1]); spanEl = createTiddlyElement(w.output, 'span', null, 'sanitized'); spanEl.innerHTML = sanitizedHTML; spanEl.setAttribute('title', cleanedTitle); w.nextMatch = this.lookaheadRegExp.lastIndex; } }, customFormat: function(w) { switch(w.matchText) { case '@@': var e = createTiddlyElement(w.output, 'span'); var styles = config.formatterHelpers.inlineCssHelper(w); if (styles.length === 0) { e.className = 'marked'; } w.subWikifyTerm(e, /(@@)/mg); break; case '{{': var lookaheadRegExp = /\{\{[\s]*([\w]+[\s\w]*)[\s]*\{(\n?)/mg; lookaheadRegExp.lastIndex = w.matchStart; var lookaheadMatch = lookaheadRegExp.exec(w.source); if(lookaheadMatch) { w.nextMatch = lookaheadRegExp.lastIndex; e = createTiddlyElement(w.output,lookaheadMatch[2] == "\n" ? "div" : "span",null,lookaheadMatch[1]); w.subWikifyTerm(e,/(\}\}\})/mg); } break; } } }; Wikifier.prototype.subWikify = function(output, terminator) { var tid = this.tiddler, spaceName = tiddlyspace.currentSpace.name, tidSpace, recipeName, stripped; try { recipeName = tid.fields['server.recipe'] || tid.fields['server.workspace']; tidSpace = tiddlyspace.resolveSpaceName(recipeName); if (tidSpace !== spaceName) { // external tiddler, so replace dangerous formatters stripped = stripHTML(tid, this.formatter); } } catch(e) { // do nothing. There's no tiddler, so assume it's safe (?!?!?) } _subWikify.apply(this, arguments); if (stripped) { // change back to the original function unstripHTML(stripped, this.formatter); } }; // replace potentially unsafe formatters with versions that strip bad HTML/CSS var stripHTML = function(tid, formatter) { var popped = {}, _handler; for (var i = 0; i < formatter.formatters.length; i++) { var f = formatter.formatters[i]; if (replaceFunctions[f.name]) { _handler = f.handler; popped[f.name] = _handler; f.handler = replaceFunctions[f.name]; } }; return popped; }; // put the original formatters back where they belong var unstripHTML = function(stripped, formatter) { for (var i = 0; i < formatter.formatters.length; i++) { var f = formatter.formatters[i]; if (stripped[f.name]) { f.handler = stripped[f.name]; } }; }; })(jQuery); //}}} [encoded data, 6288 characters]  <link href="/bags/gowers_public/tiddlers.atom" rel="alternate" type="application/atom+xml" title="gowers's public feed" /> <link rel="canonical" href="http://gowers.tiddlyspace.com/" />  !!Parent page In the light of various thoughts, we are [[looking for a property of a certain kind that might have a hope of distinguishing between functions of low circuit complexity and some given function in NP|Given what I now think, what might a "strange" simplicity property look like?]]. We have been led to consider the notion of Borel determinacy. !Introduction The idea of trying to find a finitary analogue of Borel determinacy seems to have just enough going for it to be worth exploring. This page consists of background information that is needed to understand the discussion. All this and more is covered in a series of blog posts I wrote, that start with [[this one|http://gowers.wordpress.com/2013/08/23/determinacy-of-borel-games-i/]]. However, to follow the discussion here, it is not necessary to have understood all the material in those blog posts, so I thought a shorter description would be useful. !Pruned trees An infinite rooted tree is called //pruned// if every vertex belongs to an infinite path. It is called that because if you have any infinite rooted tree, there is a unique maximal pruned subtree that you can obtain by repeatedly "pruning" its leaves until there are no longer any left. (This process may have to be repeated transfinitely often.) You can also prune the tree in one go, chopping off every vertex that does not belong to an infinite path. The main example to bear in mind is when you take all finite sequences with elements belonging to a set such as $$\{0,1\}$$ or $$\mathbb{N}$$. To make this into a tree, you join a finite sequence $$s$$ to all sequences of length one greater of which $$s$$ is an initial segment. However, while this is the example we are ultimately interested in, we need to consider more general trees in order to prove results about it. !Games on pruned trees Let $$T$$ be a pruned tree. Then we write $$[T]$$ for the set of infinite paths in $$T$$. If $$A\subset[T]$$, then we can define a game as follows. The game starts at the root, and the players take turns to name vertices. The first vertex named must be a successor of the root, and each subsequent vertex must be a successor of the vertex previously named. If these rules are adhered to, then the resulting sequence of vertices forms an infinite path in $$T$$. If that path belongs to $$A$$ then the game is a win for Player I, and otherwise it is a win for Player II. The set $$A$$ is called the //payoff set//. !Strategies and winning strategies Let us use the word "path" to refer to paths that start at the root. A //strategy for Player I// is a function $$\sigma$$ from paths of even length to vertices of $$T$$ such that if $$p$$ is a path of even length then $$\sigma(p)$$ is a successor of the last vertex of $$p$$. A strategy for Player II is defined in the same way but with "odd" replacing "even". A strategy $$\sigma$$ for Player I is a //winning strategy// if every infinite path $$(x_1,x_2,x_3,\dots)$$ such that $$x_{2r+1}=\sigma(x_1,\dots,x_{2r})$$ for every $$r$$ belongs to $$A$$. The definition of a winning strategy for Player II is similar. !Strategic subtrees The union of all infinite paths $$(x_1,x_2,x_3,\dots)$$ such that $$x_{2r+1}=\sigma(x_1,\dots,x_{2r})$$ for every $$r$$ forms a subtree of $$T$$, which I shall denote by $$S(\sigma)$$. (I'm implicitly including the root vertex in each path.) This subtree has two features. *If $$s$$ is a vertex in $$S(\sigma)$$ of even distance from the root, then $$s$$ has exactly one successor in $$S$$. *If $$s$$ is a vertex in $$S(\sigma)$$ of odd distance from the root, then every successor of $$s$$ in $$T$$ is a successor of $$s$$ in $$S(\sigma)$$. Let us call a subtree with these two properties a //strategic subtree for Player I//, or a //I-subtree// for short. It is easy to check that Player I has a winning strategy for $$A$$ if and only if there is a I-tree $$S$$ such that $$[S]\subset A$$. In a similar way we can define strategic subtrees for Player II, or """II-subtrees""", and show that Player II has a winning strategy in the game if and only if there is a """II-subtree""" $$S$$ such that $$[S]\subset A^c$$. The determinacy of a set $$A$$ can be thought of as a Ramsey theorem: it says that if we colour infinite paths red if they belong to $$A$$ and blue otherwise, then either the red set contains all the infinite paths of a I-subtree or the blue set contains all the infinite paths of a """II-subtree""". !A map defined on pairs of strategies Given a strategy $$\sigma$$ for Player I and a strategy $$\tau$$ for Player II we write $$\sigma\circ\tau$$ for the (well-defined) infinite path that results if Player I plays according to $$\sigma$$ and Player II plays according to $$\tau$$. If $$S$$ is the I-subtree of all paths consistent with $$\sigma$$ and $$S'$$ is the """II-subtree""" that does the same for $$\tau$$, then $$S\cap S'$$ consists of just the infinite path $$\sigma\circ\tau$$. !Topologizing the set of infinite paths There is a natural topology on the set of infinite paths, which coincides with the product topology when the tree comes from the set of infinite sequences with terms in a given set. The basic open sets are all sets of the form $$[T(p)]$$, where $$p$$ is a finite path in $$T$$ and $$T(p)$$ is the tree of all vertices that either belong to $$p$$ or are descendants of the end vertex of $$p$$. (That is, $$[T(p)]$$ is the set of all infinite paths that have $$p$$ as an initial segment.) !Borel sets A subset $$U$$ of $$[T]$$ is open if for every path $$x\in U$$ there is some initial segment $$p$$ of $$x$$ such that all paths in $$[T(p)]$$ belong to $$U$$. To put that loosely, if $$x\in U$$, then you only have to look at a finite amount of $$x$$ before being sure that it is in $$U$$. Again speaking loosely, a subset $$F$$ of $$[T]$$ is closed if for every path $$x$$, if all finite initial segments of $$x$$ are consistent with $$x$$ belonging to $$F$$, then $$x$$ belongs to $$F$$. (If you do not find this obvious, then it is a good exercise to see that it is essentially just a reformulation of what I have just said about open sets.) A Borel set is any set that can be built up from open and closed sets using countable intersections and countable unions (and, if you like, complements, but because we are starting with open sets and closed sets, they are not necessary). The building up process may need to continue transfinitely, and gives rise to an ordinal index that measures the "complexity" of the Borel set. !Martin's theorem Martin proved in 1975 that all Borel sets are determined. !The """Gale-Stewart""" theorem A much easier result, due to Gale and Stewart (who came up with the idea of infinite games), is that open sets (and hence also closed sets) are determined. Here is the proof. Let $$A$$ be an open subset of $$[T]$$. Call a vertex of $$T$$ //winning for Player I// if Player I has a winning strategy if the game starts at that vertex. (I won't spell out exactly what that means, but it should be obvious how to make it formal.) Then Player I has a winning strategy if and only if the root of $$T$$ is winning for Player I. Let us suppose that Player I does //not// have a winning strategy. Then Player II can play according to the following simple strategy: always move to a vertex that is not winning for Player I. (Strictly speaking, this is not a strategy but a //quasistrategy//, since it is not saying exactly what to do. But it "contains" a strategy.) Player II can always do this, since if the game is at a vertex $$x$$ that is not winning for Player I, then whatever Player I does next, Player II will have a move to a vertex that is again not winning for Player I. If Player II continues in this way, then no point will ever be reached at which all possible continuations of the sequence so far belong to $$A$$. It follows from the openness of $$A$$ that the resulting infinite sequence belongs to $$A^c$$. Actually, when I said "and hence also closed sets" above, that was slightly misleading since the determinacy of a set doesn't follow from the determinacy of its complement. However, essentially the same argument shows that if Player II does not have a winning strategy for an open set, then Player I has a winning strategy for its complement. !Lifting a game We now come to a key concept in Martin's proof of Borel determinacy. (I am not talking here about Martin's original proof, but about a simpler proof that he discovered about ten years later.) It is a little hard to take in, so I shall state the definition first and then outline various ways of thinking about it. Observe first that in the definition of a game, the rules do not depend on the payoff set. The rules of the game can be identified with the tree $$T$$ alone. So we can talk about strategies without any reference to the payoff set, except when the notion of winning or losing is involved. The definition of lifting a game does not depend on winning or losing, so that is why there is no mention of payoff sets. Let $$T$$ be a pruned tree. A //lift// of the game defined by $$T$$ is a pruned tree $$T'$$ together with a map $$\pi:T'\to T$$ and a map $$\psi$$ that takes strategies for $$T'$$ to strategies for $$T$$, with the following properties. *$$\pi$$ is a homomorphism of rooted trees. That is, $$\pi$$ takes the root of $$T'$$ to the root of $$T$$, and if $$y$$ is a successor of $$x$$ in $$T'$$, then $$\pi(y)$$ is a successor of $$\pi(x)$$ in $$T$$. *For every $$s\in[T']$$ and every $$n\in\mathbb{N}$$, the first $$n$$ terms of $$\pi(s)$$ depend only on the first $$n$$ terms of $$s$$. *If $$\sigma$$ is a strategy for $$T'$$, then every infinite path consistent with $$\psi(\sigma)$$ is the image under $$\pi$$ of at least one infinite path consistent with $$\sigma$$. A remark that makes it easier to think about whether lifts that satisfy certain conditions exist is this. Suppose that (as in practice seems to be the case) we have already decided what the map $$\pi$$ will be. Then we can define a map $$\psi$$ to satisfy the second condition if and only if the following statement holds. *The image of the strategic subtree $$S(\sigma)$$ under $$\pi$$ contains a strategic subtree of $$T$$. !!Where the payoff set comes in When we lift a game as above, we define the payoff set of the new game to be the obvious thing, namely $$\pi^{-1}(A)$$, where $$A$$ is the payoff set of the game played on $$T$$. Strictly speaking, $$\pi$$ is a map from $$T'$$ to $$T$$, but it induces a map from $$[T']$$ to $$[T]$$ in an obvious way. What's more, this induced map is easily seen to be continuous with respect to the topology described above. <<slider chkContinuityDetails "Proof of continuity of the map pi" "MoreDetails" "Give details of proof">> This implies that the Borel complexity of $$\pi^{-1}(A)$$ is no greater than that of $$A$$. What is important for Martin's proof is that the reverse is not true: $$\pi^{-1}(A)$$ can be much simpler than $$A$$. !Martin's main result, from which Borel determinacy follows Martin proved that every game with a Borel payoff set can be lifted to a game with a payoff set that is both closed and open. Let us see why that implies that games with Borel payoff sets are determined. Amongst other things, this will help to motivate the definition of lifting. The argument is simple. Let us write $$G(T,A)$$ for the game that is played on the tree $$T$$ with payoff set $$A$$. Suppose that we have a lift to a game $$G(T',\pi^{-1}(A))$$, with $$\pi$$ the map from $$T'$$ to $$T$$ and $$\psi$$ the map from strategies to strategies. Then if $$\sigma$$ is a winning strategy for Player I in the game $$G(T',\pi^{-1}(A))$$, I claim that $$\psi(\sigma)$$ is a winning strategy for Player I in the game $$G(T,A)$$. Indeed, let $$s$$ be any sequence that can result if Player I uses the strategy $$\psi(\sigma)$$. By the third property of lifts, $$s=\pi(s')$$ for some sequence $$s'$$ that can result if Player I uses the strategy $$\sigma$$ in the game $$G(T',\pi^{-1}(A))$$. Since $$\sigma$$ is a winning strategy for Player I in that game, it follows that $$s'\in\pi^{-1}(A)$$ and therefore that $$s=\pi(s')\in A$$. This proves the claim. A similar argument proves that winning strategies for Player II map to winning strategies for Player II. It follows that if the game $$G(T,\pi^{-1}(A))$$ is determined, then so is the game $$G(T,A)$$. By Martin's theorem, there is a lift such that the game $$G(T,\pi^{-1}(A))$$ //is// determined, since we can get $$\pi^{-1}(A)$$ to be both open and closed, and hence determined, by the ~Gale-Stewart theorem. !What you need to know about Martin's proof for now If Martin's proof is to serve as a model for a proof of a non-trivial property of functions of low circuit complexity, then one has to find a suitable finitary analogue of the statement and then prove it. To prove it, it will probably be necessary to have a good grasp of the details of Martin's proof, but to find the statement in the first place, I think that is not necessary. A serious problem I have is that I do not even have a good finitary analogue of the Gale Stewart theorem (something I shall discuss). So here I shall give an overview of the structure of Martin's proof, but I will not give the proof of the main lemma, which is where almost all the work is needed. In fact, I won't even state the main lemma in its full generality. ''Lemma.'' //Every game with a closed payoff set can be lifted to a game with an open (and hence closed and open) payoff set.// Once this lemma is proved, the argument goes roughly as follows. Suppose that $$A_1,A_2,\dots$$ are all Borel sets of a complexity for which we have already proved that all games are determined. We begin by lifting to a game for which the inverse image of $$A_1$$ is closed and open. When we do that, all the other sets remain at most as complex as they were before the lift. We then lift to make $$A_2$$ closed and open, and so on. We then take an inverse limit of all these lifts, which gives us a lift of the original game such that all the $$A_i$$ are closed and open. To make this inverse limit construction work, we need a stronger property than just a lift: we need to be able to create, for any $$k$$, a lift such that the first $$k$$ levels of $$T'$$ are the same as the first $$k$$ levels of $$T$$. I won't dwell on this, since it will probably be much less important in any finite analogue. Details can, however, be found in my blog posts on Borel determinacy. Once we have a lift that makes all the $$A_i$$ closed and open. we have a lift in which the set $$\bigcap_iA_i$$ is closed. Applying the main lemma, we can do one more lift to make $$\bigcap_iA_i$$ both closed and open, and we have now proved the lemma for the intersection of the $$A_i$$. To prove a similar result for unions, we can use de Morgan's laws. The sets $$A_i^c$$ have the same Borel complexities as the sets $$A_i$$, so can be lifted. Then the intersection of the $$A_i^c$$ can be lifted. And finally, taking complements (and observing that the complement of a closed and open set is closed and open), we find that the union of the $$A_i$$ can be lifted. The key step in this argument is the innocuous looking final lift, where we use the main lemma to turn the closed set $$\bigcap_iA_i$$ into a closed and open set. The rest of the proof is a relatively straightforward induction argument, with this lemma being what makes the inductive step work. One final remark about the main lemma is that it makes crucial use of the ~Gale-Stewart theorem and its proof. So if one is looking for a finitary analogue, then a preliminary step would be to find a convincing finitary analogue of the ~Gale-Stewart theorem.  [encoded data, 6536 characters] /*** |''Name''|BinaryTiddlersPlugin| |''Description''|renders base64-encoded binary tiddlers as images or links| |''Author''|FND| |''Version''|0.3.2| |''Status''|@@beta@@| |''Source''|http://svn.tiddlywiki.org/Trunk/association/plugins/BinaryTiddlersPlugin.js| |''License''|[[BSD|http://www.opensource.org/licenses/bsd-license.php]]| |''CoreVersion''|2.5| !Code ***/ //{{{ (function($) {

"use strict";

var ctfield = "server.content-type";

var plugin = config.extensions.BinaryTiddlersPlugin = {
isWikiText: function(tiddler) {
var ctype = tiddler.fields[ctfield];
if(ctype) {
if (ctype === 'text/x-tiddlywiki') {
return true;
}
return !this.isBinary(tiddler) && !this.isTextual(ctype);
} else {
return true;
}
},
// NB: pseudo-binaries are considered non-binary here
isBinary: function(tiddler) {
var ctype = tiddler.fields[ctfield];
return ctype ? !this.isTextual(ctype) : false;
},
isTextual: function(ctype) {
return ctype.indexOf("text/") === 0
|| this.endsWith(ctype, "+xml")
|| ctype === 'application/json'
|| ctype === 'application/javascript';
},
endsWith: function(str, suffix) {
return str.length >= suffix.length &&
str.substr(str.length - suffix.length) === suffix;
},
return this.isBinary(tiddler) && tiddler.text.indexOf("") !== -1;
}
};

// Disable edit for linked tiddlers (for now)
// This will be changed to a GET then PUT
config.commands.editTiddler.isEnabled = function(tiddler) {
var existingTest = config.commands.editTiddler.isEnabled;
if (existingTest) {
} else {
}
};

// hijack text viewer to add special handling for binary tiddlers
var _view = config.macros.view.views.wikified;
config.macros.view.views.wikified = function(value, place, params, wikifier,
paramString, tiddler) {
var ctype = tiddler.fields["server.content-type"];
if(params[0] === "text" && ctype && ctype !== 'text/x-tiddlywiki' &&
var el;
if(plugin.isBinary(tiddler)) {
var uri = "data:%0;base64,%1".format([ctype, tiddler.text]); // TODO: fallback for legacy browsers
if(ctype.indexOf("image/") === 0) {
el = $("").attr("alt", tiddler.title).attr("src", uri); } else { el =$("").attr("href", uri).text(tiddler.title);
}
} else {
el = $("
").text(tiddler.text); } el.appendTo(place); } else { _view.apply(this, arguments); } }; // hijack edit macro to disable editing of binary tiddlers' body var _editHandler = config.macros.edit.handler; config.macros.edit.handler = function(place, macroName, params, wikifier, paramString, tiddler) { if(params[0] === "text" && plugin.isBinary(tiddler)) { return false; } else { _editHandler.apply(this, arguments); } }; // hijack autoLinkWikiWords to ignore binary tiddlers var _autoLink = Tiddler.prototype.autoLinkWikiWords; Tiddler.prototype.autoLinkWikiWords = function() { return plugin.isWikiText(this) ? _autoLink.apply(this, arguments) : false; }; }(jQuery)); //}}} /*** |''Name''|ImageMacroPlugin| |''Version''|0.9.4| |''Description''|Allows the rendering of svg images in a TiddlyWiki| |''Author''|Osmosoft| |''License''|[[BSD|http://www.opensource.org/licenses/bsd-license.php]]| |''Notes''|Currently only works in modern browsers (not IE)| |''Requires''|BinaryTiddlersPlugin| !Usage {{{<<image SVG>>}}} will render the text of the tiddler with title SVG as an SVG image (but not in ie where it will fail silently) !!Parameters width/height: specify width/height parameters link: make the image link to a given location tiddlyLink: link to a tiddler !Notes Binary tiddlers in TiddlyWeb when passed through the wikifier will be shown as images. eg. {{{<<view text wikified>>}}} on a binary tiddler will show the image. {{{<<view fieldname image>>}}} will render the value of the tiddler field 'fieldname' as an image. This field can contain a tid {{{<<image SiteIcon>>}}} will create an image tag where the tiddler has content type beginning image and not ending +xml will attempt to create svg object in other scenarios {{{<<image /photos/x.jpg>>}}} will create an image tag with src /photos/x.jpg as long as there is not a tiddler called /photos/x.jpg in which case it will render that tiddler as an image. Note for the case of svg files it will attempt to render as an svg if possible via the image tag. It doesn't embed the svg in the dom for security reasons as svg code can contain javascript. !Code ***/ //{{{ (function($) {

var macro = config.macros.image = {
shim: "/bags/common/tiddlers/shim",
ieVersion: config.browser.isIE ? parseInt(config.browser.ieVersion[1], 10) : false,
svgns: "http://www.w3.org/2000/svg",
svgAvailable: document.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1"),
_fixPrefix: 1,
_external_cache: {},
_image_tag_cache: {},
_image_dimensions: {},
locale: {
badImage: "This image cannot be displayed."
},
handler: function(place, macroName, params, wikifier, paramString, tiddler){
var imageSource = params[0];
// collect named arguments
var args = macro.getArguments(paramString, params);
this.renderImage(place, imageSource, args);
},
init: function() {
var startupImages = store.getTaggedTiddlers("systemImage");
var place = $("
").attr("id", "systemImageArea").appendTo("body").hide()[0]; for(var i = 0; i < startupImages.length; i++) { var image = startupImages[i]; macro.renderImage(place, image.title, { idPrefix: "" }); } var data = new Image(); data.onload = function() { // note ie 8 only supports data uris up to 32k so cannot be relied on macro.supportsDataUris = this.width != 1 || this.height != 1 ? false : true; macro.supportsDataUris = macro.ieVersion && macro.ieVersion < 9 ? false : macro.supportsDataUris; }; data.onerror = data.onload; data.src = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///ywAAAAAAQABAAACAUwAOw=="; }, refreshImage: function(src) { var elements = macro._image_tag_cache[src] ? macro._image_tag_cache[src] : []; if(macro._image_dimensions[src]) { macro._image_dimensions[src] = false; } for(var i = 0; i < elements.length; i++) { var el =$(elements[i]);
var newSrc = "%0?nocache=%1".format(src, Math.random());
}
},
isBinaryImageType: function(contentType) {
return (contentType && contentType.indexOf("image") === 0 &&
contentType.indexOf("+xml") != contentType.length - 4) ? true : false;
},
isImageTiddler: function(tiddler) {
return macro.isSVGTiddler(tiddler) || macro.isBinaryImageTiddler(tiddler);
},
isSVGTiddler: function(tiddler) {
var type = tiddler ? tiddler.fields['server.content-type'] : false;
return type == "image/svg+xml";
},
isBinaryImageTiddler: function(tiddler) {
return macro.isBinaryImageType(tiddler.fields['server.content-type']);
},
renderImage: function(place, imageSource, options) {
var imageTiddler = store.getTiddler(imageSource);
var container;
var classes = ["image"];
container = $("").attr("href", options.link).appendTo(place)[0]; } else if(options.tiddlyLink) { classes.push("imageLink"); container = createTiddlyLink(place, options.tiddlyLink, false); } else { container =$("").appendTo(place)[0];
}
$(container).addClass(classes.join(" ")); options = options ? options : {}; if(imageTiddler && macro.isBinaryImageTiddler(imageTiddler)) { // handle the case where we have an image url return macro._renderBinaryImageTiddler(container, imageTiddler, options); } else if(imageTiddler){ // handle the case where we have a tiddler return macro._renderSVGTiddler(container, imageTiddler, options); } else { // we have a string representing a url return macro._renderBinaryImageUrl(container, imageSource, options); } }, _renderAlternateText: function(container, options) { var img; var src = options.src || ""; if(options.width && options.height) { img =$("").attr("src", src).addClass("svgImageText").attr("width", options.width).
attr("height", options.height).appendTo(container);
}
var alt = options.alt;
if(img && alt) {
img.attr("alt", alt).attr("title", alt);
} else if(alt) {
$(container).addClass("svgImageText").text(alt); } macro._image_tag_cache[src] = img; }, _renderSVGTiddler: function(place, tiddler, options) { if(!options) { options = {}; } merge(options, { tiddler: tiddler, fix: true}); if(macro.svgAvailable) { this._importSVG(place, options); // display the svg } else if(options.altImage) { var image = options.altImage; delete options.altImage; this._renderBinaryImageUrl(place, image, options); } else { this._renderAlternateText(place, options); // instead of showing the image show the alternate text. } }, _renderBinaryImageTiddler: function(place, tiddler, options) { var resourceURI; var fields = tiddler.fields; if(fields["server.type"] == "tiddlyweb") { // construct an accurate url for the resource resourceURI = "%0/%1/tiddlers/%2".format(config.defaultCustomFields["server.host"], fields["server.workspace"], encodeURI(fields["server.title"])); } else { // guess the url for the resource resourceURI = tiddler.title; } var ctype = fields["server.content-type"] || tiddler.type; var text = tiddler.text; if(macro.supportsDataUris && ctype && text.indexOf("<html") == -1) { var uri = "data:%0;base64,%1".format(ctype, text); options.src = resourceURI; return macro._renderBinaryImageUrl(place, uri, options); } else if(options.src) { return macro._renderBinaryImageUrl(place, options.src, options); } else { return macro._renderBinaryImageUrl(place, resourceURI, options); } }, _renderImageTag: function(container, src, width, height, options) { var img; img =$("").appendTo(container);
if(height) {
img.attr("height", height);
}
if(width) {
img.attr("width", width);
}
if(macro.ieVersion && macro.ieVersion < 7 && macro.shim && options.ie6png) {
$(img).css({width: userW, height: userH, filter: "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='%0', sizingMethod='scale')".format(src) }).attr("src", macro.shim); } else { img.attr("src", src); } if(!macro._image_tag_cache[options.srcUrl]) { macro._image_tag_cache[options.srcUrl] = []; } img =$(img).addClass(options.imageClass)[0];
macro._image_tag_cache[options.srcUrl].push(img);
return img;
},
_getDimensions: function(realDimensions, reqDimensions, preserve) {
var w = realDimensions.width;
var h = realDimensions.height;
var reqh = reqDimensions.height;
var reqw = reqDimensions.width;
var finalw = w, finalh = h;
var ratiow = reqw / w, ratioh = reqh / h;
var scaledw = ratioh * w;
var scaledh = ratiow * h;
if(!reqw && reqh) {
finalw = scaledw;
finalh = reqh;
} else if(reqw && !reqh) {
finalw = reqw;
finalh = scaledh;
} else if(reqh && reqw) {
var preserveWidth = w > h ? true : false;
if(preserve) {
if(preserveWidth && scaledh < reqh) {
finalh = scaledh;
finalw = reqw;
} else {
finalh = reqh;
finalw = scaledw;
}
} else {
finalw = reqw;
finalh = reqh;
}
}
return { width: parseInt(finalw, 10), height: parseInt(finalh, 10) };
},
_renderBinaryImageUrl: function(container, src, options) {
var srcUrl = options.src ? options.src : src;
srcUrl = srcUrl.indexOf("/") === -1 ? "/%0".format(srcUrl) : srcUrl; // for IE.
var image_dimensions = macro._image_dimensions[srcUrl];
var image = new Image(); // due to weird scaling issues where you use just a width or just a height
var createImageTag = function(dimensions, error) {
if(error) {
var altImage = options.altImage;
if(altImage) {
delete options.altImage;
macro._renderBinaryImageUrl(container, altImage, options);
} else {
options.src = src;
macro._renderAlternateText(container, options);
}
} else {
var dim = macro._getDimensions(dimensions, {
width: options.width, height: options.height }, options.preserveAspectRatio);
options.srcUrl = srcUrl;
macro._renderImageTag(container, src, dim.width, dim.height, options);
}
};

if(!image_dimensions) {
var dimensions = { width: image.width, height: image.height};
macro._image_dimensions[srcUrl] = dimensions;
createImageTag(dimensions);
};
image.onerror = function() {
createImageTag(null, true);
};
image.src = src;
} else {
createImageTag(image_dimensions);
}
},
_generateIdPrefix: function(){
return "twsvgfix_" + (this._fixPrefix++).toString() + "_";
},
_fixSVG: function(childNodes, idPrefix) {
var urlPattern = /url$$\#([^$$]*)\)*/ig;
var fixes = [
{ attr: "id", pattern: /^(.*)$/ig }, { attr: "href", namespace: macro.xlinkns, pattern: /^#(.*)$/ig }
];
var url_fixes = ["filter", "fill", "mask", "stroke", "style"];
for(var i = 0; i < url_fixes.length; i++) {
fixes.push({ attr: url_fixes[i], pattern: urlPattern });
}
for(var t = 0; t < childNodes.length; t++) {
var node = childNodes[t];
for(var a = 0; a < fixes.length; a++) {
var fix = fixes[a];
var attr = fix.attr;
var ns = fix.namespace || "";
if(node.hasAttributeNS && node.hasAttributeNS(ns, attr)) {
var v = node.getAttributeNS(ns, attr);
fix.pattern.lastIndex = 0;
var match = fix.pattern.exec(v);
if(match) {
// Make sure replacement string doesn't contain any single dollar signs
var toReplace = match[1];
if(toReplace.indexOf(idPrefix) !== 0 && toReplace.indexOf("twglobal_") !== 0) {
var replacement = (idPrefix + toReplace).replace("$", ""); v = v.replace(match[1], replacement); } node.setAttributeNS(ns, attr,v); } } } var children = node.childNodes; if(children.length > 0) { this._fixSVG(children, idPrefix); } } }, _importSVG: function(place, options){ options = options ? options : {}; var svgDoc, tiddlerText = options.tiddler.text; if (window.DOMParser) { svgDoc = new DOMParser().parseFromString(tiddlerText, "application/xml").documentElement; var idPrefix = options.idPrefix || this._generateIdPrefix(); this._fixSVG([svgDoc], idPrefix); var el = document.importNode(svgDoc, true); var svgHolder = document.createElementNS(macro.svgns,"svg"); var width = options.width; var height = options.height; if(width || height) { if(width && height) { // set view box of containing svg element based on the svg viewbox and width and height. var viewBox = el.getAttribute("viewBox"); var topLeft = "0 0"; if(viewBox) { topLeft = viewBox.replace(/([0-9]*) +([0-9]*) +([0-9]*) +([0-9]*) */gi,"$1 $2"); } svgHolder.setAttributeNS(macro.svgns, "viewBox", "0 0 %0 %1".format(width, height)); } else { if(!width) { width = el.getAttribute("width"); } if(!height) { height = el.getAttribute("height"); } } svgHolder.setAttribute("width", width); svgHolder.setAttribute("height", height); el.setAttribute("width", "100%"); el.setAttribute("height", "100%"); svgHolder.setAttribute("class", "svgImage svgIcon %0".format(options.imageClass || "")); svgHolder.appendChild(el); place.appendChild(svgHolder); } else { var existing = el.className ? el.className.baseVal : ""; el.setAttribute("class","svgImage %0".format(existing)); place.appendChild(el); } // if a tiddler attribute is set this is read as a link$("[tiddler], [tiddlyLink]", place).attr("refresh", "link").click(function(ev) {
var tiddler = $(ev.target).attr("tiddlyLink"); if(tiddler) { story.displayTiddler(ev.target, tiddler); } }); } }, getArguments: function(paramString, params) { var args = paramString.parseParams("name", null, true, false, true)[0]; var options = {}; for(var id in args) { if(true) { var p = args[id]; if(id == "def") { options[id] = p; } else { options[id] = p[0]; } } } var width = isNaN(params[1]) ? false : parseInt(params[1], 10); var height = isNaN(params[2]) ? false : parseInt(params[2], 10); options.width = macro.lookupArgument(options, "width", width); options.height = macro.lookupArgument(options, "height", height); options.preserveAspectRatio = args.preserveAspectRatio && args.preserveAspectRatio[0] == "yes" ? true : false; options.tiddlyLink = macro.lookupArgument(options, "tiddlyLink", false); options.link = macro.lookupArgument(options, "link", false); return options; }, lookupArgument: function(args, id, ifEmpty) { return args[id] ? args[id] : ifEmpty; } }; // update views var _oldwikifiedview = config.macros.view.views.wikified; // update wikifier to check tiddler type before rendering merge(config.macros.view.views, { wikified: function(value, place, params, wikifier, paramString, tiddler) { if(macro.isImageTiddler(tiddler) && params[0] == "text") { var newplace =$("
").addClass("wikifiedImage").appendTo(place)[0];
macro.renderImage(newplace, tiddler.title, { alt: macro.locale.badImage });
} else {
_oldwikifiedview.apply(this, arguments);
}
},
image: function(value, place, params, wikifier, paramString, tiddler) {
// a field can point to another tiddler whereas text is the current tiddler.
var title = params[0] == "text" ? tiddler.title : value;
var args = macro.getArguments(paramString, params);
macro.renderImage(place, title, args);
}
});
config.shadowTiddlers.StyleSheetImageMacro = [".wikifiedImage svg, .wikifiedImage .image { width: 80%; }",
".svgImageText { background-color:[[ColorPalette::Error]]; color:#ddd; display: inline-block; }",
"span.svgImageText { display: inline-block; overflow: hidden; }"
].join("");

})(jQuery);
//}}}
!!Parent page

We are trying to determine [[whether there is an efficient lift for the parity function|Is there an efficient Ramsey lift for the parity function?]].

!Introduction

Consider the following candidate for an efficient lift of the parity function. Let $$m=n/2$$. The sequences are of the form $$(y_1,\dots,y_n)$$, where $$y_i\in\{0,1\}$$, except when $$i=m+1$$, where we have  $$y_{m+1}\in\{0,1\}^2$$. The structure $$Y$$ consists of all sequences $$(x_1,x_2,\dots,x_m,(x_{m+1},\eta),x_{m+2},\dots,x_n)$$ such that $$\eta$$ is the parity of $$(x_1,\dots,x_n)$$, and $$\pi:Y\to\{0,1\}^n$$ is defined by $$\pi(x_1,x_2,\dots,x_m,(x_{m+1},\eta),x_{m+2},\dots,x_n)=(x_1,\dots,x_n)$$. If $$A$$ is the set of all sequences of odd parity, then $$\pi^{-1}(A)$$ is the basic set $$\{y:y_{m+1}\in\{(0,1),(1,1)\}\}$$.

!Proof that this is not a Ramsey lift.

Let $$n=6$$. Consider the set $$W\subset\{0,1\}^6$$ that consists of all sequences $$(x_1,\dots,x_6)$$ such that at least one of the following conditions holds.
#$$x_1\ne x_4$$.
#$$x_5\ne x_6$$.
#$$x_2=x_5$$ and $$x_3=x_6$$.

''Claim 1.'' $$W^c$$ is a winning set for Player II.

''Proof of Claim 1.'' When Player I plays $$x_1$$ (which may not be her first move), Player II responds by playing $$x_4$$ and ensuring that $$x_1=x_4$$. When Player I first plays one of $$x_2$$ and $$x_3$$, Player II responds by ensuring that $$x_2\ne x_5$$ or $$x_3\ne x_6$$. The next time Player I plays one of $$x_2$$ and $$x_3$$, Player II plays $$x_5$$ or $$x_6$$ (whichever is left to play) and makes sure that $$x_5\ne x_6$$. In that way, Player II ensures that none of the three conditions holds, thereby winning the game with payoff set $$W^c$$.

''Claim 2.'' $$\pi^{-1}(W)$$ is a winning set for Player I.

''Proof of Claim 2.'' Player I begins by playing $$y_1=0$$.

If Player II responds with $$y_4$$, then he is forced to play either $$y_4=(0,0)$$ or $$y_4=(0,1)$$ (since Player II requires $$x_1$$ to equal $$x_4$$). In other words, in the original game it forces Player II to choose $$x_4$$ //and// to commit both players to the parity of the eventual sequence.

Player I now chooses $$y_2$$ and $$y_3$$ in such a way that the parity of $$(y_1,y_2,y_3,y_4)$$ is not the parity that Player II declared in the second coordinate of $$y_4$$. That forces Player II to choose $$y_5$$ and $$y_6$$ to have total parity 1, and therefore to be distinct, which means that the second condition is satisfied and the resulting sequence belongs to $$\pi^{-1}(W)$$.

If Player II responds with $$y_5$$, then Player I chooses $$y_2$$ to equal $$y_5$$. If Player II chooses $$y_6$$, then Player I chooses $$y_3$$ to equal $$y_6$$ and wins by achieving condition 3. If Player II chooses $$y_4$$, then Player I chooses $$y_3$$ to equal $$y_5$$. But now Player II needs $$y_5=y_6$$ and also $$y_3\ne y_6$$, which is impossible, so Player I wins.

By symmetry, Player I wins if Player II responds to Player I's first move with $$y_6$$.
/*{{{*/
Background: #f6f8dc
Foreground: #202206
PrimaryPale: #fdfefa
PrimaryLight: #eaedc4
PrimaryMid: #b0b648
PrimaryDark: #53534a
SecondaryPale: #fdfafe
SecondaryLight: #e4c4ed
SecondaryMid: #9e48b6
SecondaryDark: #514a53
TertiaryPale: #fafdfe
TertiaryLight: #c4e0ed
TertiaryMid: #4893b6
TertiaryDark: #4a5053
Error: #f88
ColorPaletteParameters: HSL([63|44], [0.67|0.53|0.43|0.06],[0.31|0.5|0.85|0.99])
/*}}}*/
Unless you're delighted with the default theme you can make some quick changes by generating a new random color palette, hit this button to cycle through some alternatives.

<<RandomColorPaletteButton saturation_pale:0.67 saturation_light:0.53
saturation_mid:0.43 saturation_dark:0.06 pale:0.99 light:0.85 mid:0.5 dark:0.31>>

You can also change the look and feel completely by installing a new theme. To do this, find one you like in the @themes space, note down the name, and include it in this space by going to the space menu. You can reach the space menu by clicking on the blue and pink circle at the top-right of the page and chooshing "THIS SPACE". Here are a few to check out:
* @pip
* @caspian-ii
* @basalt
* @simplicity
* @cheesecake
* @jelly-doughnut

(//Note that if you are using a custom TiddlySpace install, these themes may not be present.//)

It is easy to see that a set of leaves of an $$r$$-ary subtree has the required property. Conversely, given a set of leaves with the required property, partition them into clusters that all have distance 1 from each other. (Note that the relation $$d(x,y)\leq 1$$ is an equivalence relation: it is the relation that $$x$$ and $$y$$ have the same vertex as parent.) Now define a distance between clusters by taking the distances between the vertices in the clusters (which are the same for every pair of vertices, one from one cluster and one from the other) and subtracting 1. That gives us a subset of the set of parents of leaves, which has the same property we started with but for a tree with $$n-1$$ levels. Therefore in one direction the result is true by an easy induction.
<?xml version="1.0" encoding="UTF-8" standalone="no"?>

<svg
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:cc="http://creativecommons.org/ns#"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:svg="http://www.w3.org/2000/svg"
xmlns="http://www.w3.org/2000/svg"
version="1.1"
width="14pt"
height="14pt"
viewBox="918 510 14 14"
id="svg3070">
<rdf:RDF>
<cc:Work
<dc:format>image/svg+xml</dc:format>
<dc:type
rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
<dc:title></dc:title>
</cc:Work>
</rdf:RDF>
<defs
id="defs3072">
cx="0"
cy="0"
r="1"
<stop
id="stop3075"
style="stop-color:#ffffff;stop-opacity:1"
offset="0" />
<stop
id="stop3077"
style="stop-color:#2b2b2b;stop-opacity:1"
offset="1" />
</defs>
<g
id="g3080"
style="fill:none;stroke:none">
<g
id="g3082">
<path
d="m 929.6952,512.9018 c -2.5384,-2.53843 -6.654,-2.53843 -9.1924,0 -2.5384,2.5384 -2.5384,6.654 0,9.19238 2.5384,2.53839 6.654,2.53839 9.1924,0 2.5384,-2.53838 2.5384,-6.65398 0,-9.19238 m -4.5962,2.8407 2.07733,-2.07734 1.75547,1.75549 -2.0773,2.07735 2.0773,2.07732 -1.75547,1.75548 -2.07733,-2.07732 -2.07733,2.07732 -1.75547,-1.75548 2.0773,-2.07732 -2.0773,-2.07735 1.75547,-1.75549 z"
id="path3084"
<path
d="m 927.61447,515.38354 a 4.51205,4.2590378 0 1 1 -9.0241,0 4.51205,4.2590378 0 1 1 9.0241,0 z"
transform="matrix(1.0218069,0,0,1.0462046,-18.063694,-21.648443)"
id="path2394"
style="fill:#000000;fill-opacity:0;fill-rule:evenodd;stroke:none;stroke-width:5;marker:none;visibility:visible;display:inline;overflow:visible;enable-background:accumulate" />
</g>
</g>
</svg>
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
<svg xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns="http://www.w3.org/2000/svg" height="100%" width="100%" version="1.1" xmlns:cc="http://creativecommons.org/ns#" xmlns:dc="http://purl.org/dc/elements/1.1/" viewBox="0 0 40 40"><metadata><rdf:RDF><cc:Work rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage"/><dc:title/></cc:Work></rdf:RDF></metadata><defs><linearGradient id="lG3826" x1="7.0996" gradientUnits="userSpaceOnUse" y1="18.829" gradientTransform="matrix(1.5858347,0,0,1.8078238,1098.1851,351.13716)" x2="1.5461" y2="-0.95166"><stop stop-color="#000" offset="0"/><stop stop-color="#9c9b99" offset="1"/></linearGradient><linearGradient id="lG3828" y2="372.44" gradientUnits="userSpaceOnUse" y1="375.7" x2="1111.7" x1="1097.7"><stop style="stop-color:#ac9393;" offset="0"/><stop style="stop-color:#c8b7b7;" offset="1"/></linearGradient></defs><g transform="translate(-1080.9375,-357.3329)"><path style="stroke-width:0;stroke-miterlimit:4;fill:url(#lG3826);" d="m1080.9,357.32,39.996-0.0426-0.01,40.008c-15.507-25.519-15.36-25.95-39.988-39.965z"/><path style="stroke-dashoffset:0;stroke:#7aa3be;stroke-linecap:round;stroke-miterlimit:4;stroke-width:1.49999988;fill:#c1e6fd;" d="m1091.9,363.55c6.5716-6.4925,16.576-7.3925,23.147-0.90003,6.5717,6.4925,6.5717,17.019,0,23.511-4.4424-8.6113-12.288-15.713-23.147-22.611z"/><path style="stroke-dashoffset:0;stroke:#ce81b0;stroke-linecap:round;stroke-miterlimit:4;stroke-width:1.5;fill:#f4c4e2;" d="m1110.2,367.62c3.217,3.2168,3.217,8.4323,0,11.649-3.8194-4.2357-8.3307-8.1824-11.649-11.649,3.217-3.2168,8.4325-3.2168,11.649-0.00002z"/><path style="stroke-linejoin:bevel;stroke:#000000;stroke-linecap:round;stroke-dasharray:none;stroke-miterlimit:4;stroke-width:0.80000001;fill:url(#lG3828);" d="m1081,357.34c18.79,6.4752,32.53,16.56,39.894,39.892-11.19-17.028-14.878-19.19-27.352-14.96,6.2984-12.098,3.9371-13.19-12.542-24.932z"/></g></svg>
!!Parent page

We are trying to establish [[whether trivial lifts can reduce circuit complexity|Can trivial lifts be used to simplify sets?]].

!Introduction

Recall the following definitions.

Let $$X\subset\Gamma^n$$ and $$Y\subset\Theta^n$$. A //trivial lift// from $$Y$$ to $$X$$ is a map $$\pi$$ such that the following condition holds. For every set $$K\subset\{1,2,\dots,n$$\) that is not the whole of $$\{1,2,\dots,n\}$$, every set of specifications $$x_i=\gamma_i$$ ($$i\in K$$), every set of specifications $$y_i=\theta_i$$ ($$i\in K$$) such that $$\pi(\theta_i)=\gamma_i$$ for each $$i\in K$$ and every specification $$x_j=\gamma_j$$ for some $$j\notin K$$ that is consistent with the specifications of the $$x_i$$ for $$i\in K$$, there is a specification $$y_j=\theta_j$$ consistent with the specifications of the $$y_i$$ for $$i\in K$$ such that $$\pi(\theta_j)=\gamma_j$$.

A //super-trivial// lift is one where $$\phi:\Theta\to\Gamma$$ is a surjection, $$\pi(\theta_1,\dots,\theta_n)$$ is defined to be $$(\phi(\theta_1),\dots,\phi(\theta_n))$$, and $$Y$$ is defined to be $$\pi^{-1}(X)$$. So all $$\pi^{-1}$$ does is duplicate coordinates several times. It is easy to show that a super-trivial lift is trivial.

It is also not hard to show that super-trivial lifts cannot decrease circuit complexity. [[The proof can be found on a sister page to this one|Can super-trivial lifts reduce circuit complexity?]]. However, if each $$\gamma\in\Gamma$$ has enough preimages (under $$\phi$$) in $$\Theta$$, then we can pass to a random subset of $$Y$$ and retain the triviality property. If we do this, then the simple proof that circuit complexity cannot be reduced breaks down. This page is devoted to the question of whether the result nevertheless remains true. The hope is that it does and that the proof will be sufficiently general to allow us to show that no trivial lift can reduce circuit complexity.

!A sketchy counting argument that looks correct

I'll consider the case where $$X=\{0,1\}^n$$. Suppose that $$A\subset\{0,1\}^n$$. Let $$\pi:Y\to X$$ be a super-trivial lift and let $$Z$$ be a random subset of $$Y$$ such that the restriction of $$\pi$$ to $$Z$$ gives us a trivial lift. Let the elements of $$Z$$ be chosen from $$Y$$ with probability $$p$$. Let the alphabet of $$Y$$ be $$\Gamma_0\cup\Gamma_1$$, with $$\Gamma_0$$ going to $$0$$ and $$\Gamma_1$$ going to $$1$$. For simplicity, let's assume that $$\Gamma_0$$ and $$\Gamma_1$$ have the same size.

Let $$C\subset Z$$ and let $$C_1,\dots,C_m$$ be a straight-line computation of $$C$$, <<slider chkStraightLineDefinition "The circuit complexity of a subset of a complexity structure" "What's that?" "Reminder of definition">> where $$m$$ is polynomial in $$n$$, or perhaps a bit bigger but in any case well short of exponential. For each $$C_i$$ that is a basic set in $$Z$$, let $$B_i$$ be the corresponding basic set in $$Y$$. With high probability this is well defined. (That is, with high probability there will not be two distinct basic subsets of $$Y$$ that have the same intersection with $$Z$$.) Therefore, we can define a corresponding straight-line computation $$B_1,\dots,B_m$$ in $$Y$$, which will have the property that $$B_i\cap Z=C_i$$ for each $$i$$.

The number of possible sets $$B_i$$ that can arise, which are the sets of circuit complexity at most $$m$$, is not more than $$m^{cm}$$. Therefore, with very high probability $$|B\cap Z|\approx p|B|$$ for all such sets.

Combining the proof [[that super-trivial lifts cannot reduce circuit complexity|Can super-trivial lifts reduce circuit complexity?]] with an averaging argument, we get (I'm almost certain) that if $$r$$ is smaller than the circuit complexity of $$A$$ and $$B_1,\dots,B_r$$ is a straight-line computation of a set $$B$$, then the symmetric difference of $$B$$ and $$\pi^{-1}(A)$$ has density at least about $$2^{-n}$$ in $$Y$$. Therefore, with very high probability, the symmetric difference of $$B\cap Z$$ with $$\pi^{-1}(A)\cap Z$$ will, with very high probability, have density at least about $$2^{-n}$$ in $$Z$$.

For now, I shall work on the assumption that this argument is basically correct.

This is just a matter of understanding the definition of the topology. By definition, a map $$\theta$$ from $$[T']$$ to $$[T]$$ is continuous if for every sequence $$s\in[T']$$ and every $$n\in\mathbb{N}$$ there exists $$m\in\mathbb{N}$$ such that if $$t\in[T']$$ is any sequence that agrees with $$s$$ in the first $$m$$ places, then $$\theta(t)$$ agrees with $$\theta(s)$$ in the first $$n$$ places. The condition that the first $$n$$ places of $$\pi(s)$$ depend only on the first $$n$$ places of $$s$$ tells us that in the case $$\theta=\pi$$ we may take $$m=n$$.
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xl="http://www.w3.org/1999/xlink" version="1.1" viewBox="506 234 68 36" width="30" height="30"><metadata xmlns:dc="http://purl.org/dc/elements/1.1/"><dc:date>2010-09-16 14:51Z</dc:date></metadata><defs></defs><g stroke="none" stroke-opacity="1" stroke-dasharray="none" fill="none" fill-opacity="1"><rect width="1118" height="783"/><g><path d="M 538.68195 244.31807 C 540.43927 246.07547 540.43927 248.9247 538.68195 250.68204 C 536.92456 252.4394 534.07532 252.4394 532.318 250.68204 C 530.5606 248.9247 530.5606 246.07547 532.318 244.31807 C 534.07532 242.56075 536.92456 242.56075 538.68195 244.31807 M 511.12607 257.99356 C 511.26108 258.13019 511.39728 258.26608 511.53473 258.40121 C 527.2556 273.86606 552.74414 273.86606 568.46515 258.40121 C 568.60248 258.26617 568.73853 258.13037 568.87354 257.9938 C 568.8736 257.99374 568.8736 257.99371 568.8736 257.99362 C 568.87366 257.99371 568.87366 257.9938 568.87372 257.9939 C 570.72504 256.12051 572.35046 254.11153 573.74994 252 C 573.74994 251.99997 573.74994 251.99994 573.74994 251.99992 C 572.35046 249.8884 570.72504 247.87938 568.87372 246.00606 C 568.87366 246.00613 568.87366 246.00621 568.8736 246.00627 C 568.73865 245.86966 568.60254 245.73383 568.46515 245.5987 C 552.74414 230.13387 527.2556 230.13387 511.53473 245.5987 C 511.39728 245.73383 511.26108 245.86974 511.12613 246.00635 C 511.126 246.00624 511.126 246.00616 511.12595 246.00606 C 509.2748 247.87938 507.64954 249.88837 506.24994 251.9998 L 506.24994 251.99983 C 506.24994 251.9999 506.25 251.99992 506.25 251.99997 C 506.25 252 506.24994 252.00005 506.24994 252.00009 L 506.24994 252.00012 C 507.64954 254.11157 509.2748 256.12051 511.12595 257.9939 C 511.126 257.99377 511.126 257.99365 511.12607 257.99359 Z M 515.44916 252 C 515.8548 251.55469 516.27502 251.11778 516.71014 250.68985 C 522.16632 245.32257 529.06055 242.23206 536.17273 241.41824 C 534.6662 241.96199 533.2525 242.83762 532.04498 244.04512 C 527.65155 248.43852 527.65155 255.56163 532.04498 259.95502 C 533.2522 261.16226 534.6656 262.03778 536.17175 262.58154 C 529.05988 261.76761 522.16608 258.6771 516.71014 253.31009 C 516.2751 252.88219 515.85486 252.44528 515.44922 252 Z M 564.55054 251.99995 C 564.14502 252.44525 563.7248 252.88217 563.28973 253.31009 C 557.83368 258.67712 550.93988 261.76764 543.828 262.58157 C 545.33423 262.03781 546.74756 261.1623 547.9549 259.95502 C 552.34833 255.56163 552.34833 248.43852 547.9549 244.04512 C 546.74744 242.83765 545.33374 241.96202 543.82715 241.41824 C 550.9394 242.23206 557.83356 245.3226 563.28973 250.68985 C 563.7248 251.11775 564.14502 251.55467 564.55054 251.99995 Z M 568.8736 257.99362 C 570.7249 256.12033 572.35028 254.11139 573.74988 252.00002" fill="black" class="glyph"/></g></g></svg>

''Definition.'' A //complexity structure// is a subset $$X$$ of a set $$\Gamma^n$$. Given such a structure, the //basic sets// are all sets of the form $$\{x\in X:x_i\in\Delta\}$$ for some $$1\leq i\leq n$$ and some subset $$\Delta$$ of $$\Gamma$$.

''Definition.'' A //lift// of a complexity structure $$X$$ is a complexity structure $$X'$$ and a map $$\pi:X'\to X$$ such that for every $$x',y'\in X'$$ and every $$1\leq i\leq n$$, if $$x_i'=y_i'$$ then $$\pi(x')_i=\pi(y')_i$$.

The condition here is saying that the $$i$$th coordinate of $$\pi(x')$$ depends only on the $$i$$th coordinate of $$x'$$.

These definitions are taken from [[this page|Can we find an analogue of Martin's theorem by thinking about more general Ramsey properties?]].

!!Parent page

We want to know [[whether there are any interesting examples of efficient Ramsey lifts|Are there some interesting examples of efficient Ramsey lifts?]].

!Introduction

It seems to be hard to find interesting examples of Ramsey lifts, because it is quite a delicate matter to add "extra information" without giving an advantage to one of the two players. To get a feel for that, I would like to try to understand "semi-Ramsey" lifts, where the winning sets of one player lift to winning sets of the same player, but we don't say anything about the other player. If we can understand such lifts reasonably well, then maybe there will be a chance of understanding the intersection of the set of lifts that preserve Player I's winning sets and the set of lifts that preserve Player II's winning sets.

!Are there trivial examples of lifts that preserve Player I's winning sets?

One source of trivial examples is any lift that gives Player I the option of playing the original game. For example, suppose that Player I accompanies her first move by the declaration of some subset of cardinality at least $$|X|/2$$ inside which the game must take place and the rest of the game takes place inside that subset. Then she has the option of declaring $$X$$ itself as that subset, so if $$W$$ is a """I-winning""" set in the original game, then it is in this new game.

!What would count as an interesting example?

For now I'll restrict attention to the simplifying question that I've used to think about a number of questions like this. I consider auxiliary games of the following kind. (They are not lifts, but they are closely related to lifts.) Player I offers Player II a choice of subsets of $$X$$. Then Player II chooses a subset from amongst those offered by Player I. Then the two players play the game within the subset chosen by Player II.

More formally, Player I gets to choose some $$\mathcal{X}_u$$ from a set $$\{\mathcal{X}_u:u\in U\}$$, where each $$\mathcal{X}_u$$ is a set of subsets of $$X$$. Player II then chooses $$V\in\mathcal{X}_u$$. Finally, the two players play the shrinking-neighbourhoods game in $$V$$. If the payoff set in the original game was $$W$$, then the payoff set in the new game after the two initial moves is $$V\cap W$$.

The property we want the auxiliary game to have is that if $$W$$ is a """I-winning""" set, then Player I wins the auxiliary game with $$W$$ as well. A minimum requirement for making it interesting is that Player I should not be able to force $$V$$ to be $$X$$ itself: that is, the auxiliary game should involve some reduction of the payoff set.

However, that is not all. For example, suppose that every $$\mathcal{X}_u$$ is a singleton consisting of a set of the form $$\{x:x_i=\gamma_i,x_j=\gamma_j\}$$ and that all such sets are available to Player I. Then if $$W$$ is a """I-winning""" set, she can pick the first move $$x_i=\gamma_i$$ of a winning strategy for $$W$$ and some arbitrary move $$x_j=\gamma_j$$ for Player II. If the game takes place inside that set, then she plays as though the first two moves in the original game were $$x_i=\gamma_i$$ and $$x_j=\gamma_j$$, except that when Player II plays $$x_j=\gamma_j$$ then she plays $$x_i=\gamma_i$$ immediately afterwards.

That example is still uninteresting because there isn't really any give and take. To make it interesting we would want Player I to offer a wide range of options. That would be the "give", but the "take" would be that Player I would have many different ways of making the offer, so could try to find the one that was most advantageous, given the payoff set.
!!Parent page

We have been wondering [[whether it is possible to find a finitary theorem with a proof that is based on Martin's proof of Borel determinacy but with a substantially modified statement|Can we find an analogue of Martin's theorem by thinking about more general Ramsey properties?]].

!Introduction

We are aiming to find a property of subsets of $$\{0,1\}^n$$ that follows "interestingly" from the property of having circuit complexity at most $$m$$. (If we could show that some NP function fails to have that property, we would of course be ecstatic, but for now we are not thinking about that, since the more modest objective is quite hard enough.)

We have the following plan for what the property might be. For every complexity structure $$X$$ we define classes of sets $$\mathcal{F}(X)$$ and $$\mathcal{G}(X)$$. We define a //Ramsey lift// of $$X$$ to be a lift $$\pi:Y\to X$$ with the property that if $$F\in\mathcal{F}(Y)$$ then $$\pi(F)$$ has a subset in $$\mathcal{F}(X)$$ and if $$G\in\mathcal{G}(Y)$$ then $$\pi(G)$$ has a subset in $$\mathcal{G}(X)$$. We have some notion of "very simple": if a set is very simple then it means that it can be built out of basic sets in a simple way. And then our non-trivial property is roughly this: there exists a Ramsey lift of $$\{0,1\}^n$$ with an alphabet that is not too large. <<slider chkRepeatLiftDefinitions "Complexity structures and lifts" "What did all that mean?" "Reminder of definitions">>

I have no idea whether anything like this could work, so I want to think about what the set systems  $$\mathcal{F}(X)$$ and $$\mathcal{G}(X)$$ would have to be like. It may be that there will be enough requirements on them that they cannot exist, but if that's the case, then I think I will have learnt something interesting.

!A few decisions that need to be made

In the analogous situation with games and trees, the Ramsey property allows one to find either a strategic subtree for Player I with all its leaves in $$A$$ or a strategic subtree for Player II with all its leaves in $$A^c$$. <<slider chkStrategicSubtreeDefinition "What is a strategic subtree?" "Meaning?" "Reminder of definition">> These sets have the following quite unusual combination of properties.
#The Ramsey property just stated.
#Given any strategic subtree for Player I and any strategic subtree for Player II there is exactly one leaf that belongs to both subtrees.

The proofs of both these properties are fairly straightforward, but that appears to derive in large part from the simplicity of the tree structure. So it is not at all clear whether it is realistic to hope for set systems with these properties in the modified situation. Let me ask the question precisely.
#Do we want it to be the case that for every $$A\subset X$$, either $$A$$ contains a set in $$\mathcal{F}(X)$$ or $$A^c$$ contains a set in $$\mathcal{G}(X)$$?
#Do we want it to be the case that $$|F\cap G|=1$$ for every $$F\in\mathcal{F}(X)$$ and every $$G\in\mathcal{G}(X)$$?
Another question we might ask is whether, if we do have one or other of these properties, the proof that the property is satisfied should be simple? And a related one is whether we should somehow try to model the property on determinacy. (What I mean by modelling a property on determinacy is aiming for a property that is to complexity structures as determinacy is to trees.)

A different matter about which a decision needs to be made is this: what counts as a "very simple" set? What, that is, plays the role here that closed and open sets play in the proof of Martin's theorem? Basic sets are, I think, //too// simple for this purpose. One possibility might be to define a basic open set to be a union of a small number of basic sets, and an open set to be a union of basic open sets (so it's basically a set defined fairly efficiently by a formula in DNF, at least if we don't allow the union to be too large). A closed set would be a complement of an open set. Then we could try to lift a closed set to an open set, and the result would be clopen (since $$\pi$$ is "continuous"). The advantage of this approach is that it is sticking reasonably close to what we know works in a different context.

!What proof-finding strategy would be appropriate at this point?

We are facing a familiar problem in mathematical research. We want to find an object that belongs to a large and unstructured class (the class of pairs of set systems $$\mathcal{F}(X)$$ and $$\mathcal{G}(X)$$), and we want it to have a rather complicated property (the property that there exists an efficient Ramsey lift for sets of low circuit complexity and there does not exist an efficient Ramsey lift for arbitrary sets). Given how large the class inside which we are looking is, it is unrealistic to hope to find such an object by pure guesswork, so what do we do? Here are a few candidate techniques.

"""LookForSomethingMoreSpecific""": try to add a reasonably simple property that will make the class of objects in which we are searching significantly smaller without stopping what we are looking for from existing.

"""SuspendObject""": pretend we have already chosen the object and start proving that it has the required properties; if at any point we need the object to have properties to make the proof work, hope that those properties are simpler than the ones we are trying to prove.

"""UseAnalogy""": take an analogous situation where things work and try to ask what in this situation would be "the equivalent" of what we have in that one.

"""TryToShowImpossible""": look for a proof that no object can possibly have the properties required, and if the proof seems to fail, try to understand why and use that understanding to generate an example. (What one says is roughly this: I'm trying to show that object $$O$$ cannot have properties $$P$$; the natural proof attempt fails because $$O$$ might have properties $$Q$$. Then one goes back to the original problem but narrowing down the search by adding the property $$Q$$.)

"""GuessAndAdjust""": make a guess that is not completely stupid, perhaps with the help of """UseAnalogy"""; if it fails for some reason, then try to modify the guess in such a way that that reason will no longer apply.

I don't see much mileage in """SuspendObject""" just at the moment: without some purchase on what the set systems actually are, I don't see how to begin trying to prove that they have the required properties. I think """TryToShowImpossible""" could be a useful thing to do at some point (particularly as there is a pretty good chance that it //is// impossible), but I don't want to do that for now. I find myself drawn to a mixture of """LookForSomethingMoreSpecific""", """UseAnalogy""" and """GuessAndAdjust""".

Let me elaborate on that slightly. A condition that I think it is natural to place on the set systems is invariance under permutations of the ground set. I might want to modify that at some point, because I don't rule out generalizing the notion of complexity structures to subsets of sets of the form $$\Gamma_1\times\dots\times\Gamma_n$$ with the $$\Gamma_i$$ not all equal. But even then I think I'd like the //definitions// of the set systems to be in some sense invariant. (I think what I mean by that is that the definitions are allowed to depend on the $$\Gamma_i$$ but not on the indices $$i$$ themselves. So if, for example, $$\Gamma_i=\Gamma_j$$, then the set systems will be invariant under switching $$i$$ and $$j$$ around. I'm sure there's some clean way of saying all this.)

It also seems to be a good idea to apply """UseAnalogy""": after all, the //whole point// of this approach is to draw an analogy with Martin's theorem, and the further away we get from that, the weaker the argument becomes that because Martin's theorem gives us a non-trivial consequence of the property of being Borel, an analogous result might give us a non-trivial consequence of the property of having low circuit complexity. Since the argument is hanging on by a thread anyway, the less we can do to weaken it, the better.

And finally, """GuessAndAdjust""" is a technique that goes naturally with """UseAnalogy""": you guess what some analogous object or concept should be and you adjust your guess if it turns out to be unsatisfactory.

This gives us a strategy for what to do next.

!What next?

Let us try to answer the following question.

What two classes of sets could serve as a "symmetric analogue" of the classes of strategic subtrees for Player I and Player II?  [[LookForSomethingMoreSpecific|What two classes of sets could serve as a "symmetric analogue" of the classes of strategic subtrees for Player I and Player II?]]
There are a lot of interesting people using ~TiddlySpace that you might like to keep track of and interact with. There are a number of ways of doing this.

If you see a number in the speech bubble in one of your tiddlers, it means that someone is writing about the same thing as you. You can find out what they're saying by clicking on it. Likewise, if you see something interesting in someone else's space, you can respond to it and write up your own thoughts on the subject by clicking "Reply to this tiddler".

Additionally, if you find anyone interesting, or you find an interesting looking space and you'd like to know when it's changed, you can "follow" that space. To do this, simply create a tiddler with the title: {{{@space-name}}} and tag it {{{follow}}}. If you want, you can store some notes about that space in the body of the tiddler.

If you then want to know what happening, simply [[include|How do I include/exclude spaces?]]@docs the @tivity space and then visit your activity stream at [[/activity|/activity]], or just visit the @tapas space directly.

!Not sure who to follow?
Here's a few suggestions:
* @fnd
* @cdent
* @pmario
* @bengillies
* @dickon
/***
|''Name''|TiddlySpaceFollowingPlugin|
|''Version''|0.7.1|
|''Description''|Provides a following macro|
|''Author''|Jon Robson|
|''Requires''|TiddlySpaceConfig TiddlySpaceTiddlerIconsPlugin ErrorHandler|
!Usage
Tag a tiddler with "follow" to express a list of followers.
Using the {{{<<followTiddlers X>>}}}
will reveal the number of tiddlers with name X in the set of spaces the *current* user viewing your space follows.
{{{<<following jon>>}}} will list all the users following Jon.
{{{<<followers jon>>}}} will list all the followers of jon.
{{{<linkedTiddlers>>}}} will list all tiddlers across TiddlySpace linked to the current tiddler
{{{<linkedTiddlers follow:yes>>}}} will list all tiddlers across TiddlySpace that come from your list of followers
{{{<<view server.bag spaceLink title>>}}} makes a link to the tiddler with title expressed in the field title in space server.bag
If no name is given eg. {{{<<following>>}}} or {{{<<follow>>}}} it will default the current user.
!StyleSheet
.followTiddlersList li {
list-style:none;
}

.followButton {
width: 2em;
}

.followTiddlersList li .siteIcon {
height:48px;
width: 48px;
}

#sidebarTabs .followers li a,
.followers .siteIcon,
.followers .siteIcon div {
display: inline;
}

.followTiddlersList li .externalImage, .followTiddlersList li .image {
display: inline;
}

.scanResults li {
list-style: none;
}
!Code
***/
//{{{
(function($) { var LIMIT_FOLLOWING = 100; var tweb = config.extensions.tiddlyweb; var tiddlyspace = config.extensions.tiddlyspace; var currentSpace = tiddlyspace.currentSpace.name; var shadows = config.shadowTiddlers; config.annotations.ScanTemplate = "This tiddler is the default template used in the display of tiddlers founding using the tsScan macro. To access attributes use the view macro e.g. {{{<<view title text>>}}}"; shadows.ScanTemplate = "<<view modifier SiteIcon width:24 height:24 spaceLink:yes label:no>> <<view title link>>"; shadows.FollowersTemplate = "<<view server.bag SiteIcon width:24 height:24 spaceLink:yes label:no>> <<view server.bag spaceLink>>"; shadows.FollowingTemplate = "<<view title SiteIcon width:24 height:24 spaceLink:yes label:no>> <<view title spaceLink>>"; shadows.FollowTiddlersBlackList = ""; shadows.FollowTiddlersHeading = "There are tiddlers in spaces you follow using the follow tag which use the title <<view title text>>"; shadows.FollowTiddlersTemplate = ["* <<view server.space SiteIcon width:24 height:24 spaceLink:yes label:no>> ", "<<view server.space spaceLink title external:no>> modified by <<view modifier spaceLink>> ", "in the <<view server.space spaceLink>> space (<<view modified date>> @ <<view modified date 0hh:0mm>>).\n"].join(""); var name = "StyleSheetFollowing"; shadows[name] = "/*{{{*/\n%0\n/*}}}*/". format(store.getTiddlerText(tiddler.title + "##StyleSheet")); store.addNotification(name, refreshStyles); // provide support for sucking in tiddlers from the server tiddlyspace.displayServerTiddler = function(src, title, workspace, callback) { var adaptor = store.getTiddlers()[0].getAdaptor(); var localTitle = tiddlyspace.getLocalTitle(title, workspace); var tiddler = new Tiddler(localTitle); tiddler.text = "Please wait while this tiddler is retrieved..."; tiddler.fields.doNotSave = "true"; store.addTiddler(tiddler); src = story.displayTiddler(src || null, tiddler.title); tweb.getStatus(function(status) { var context = { host: tweb.host, // TODO: inherit from source tiddler? workspace: workspace, headers: { "X-ControlView": "false" } }; var getCallback = function(context, userParams) { var tiddler = context.tiddler; tiddler.title = localTitle; store.addTiddler(tiddler); story.refreshTiddler(localTitle, null, true); // overriding existing allows updating if(callback) { callback(src, tiddler); } }; adaptor.getTiddler(title, context, null, getCallback); }); }; tiddlyspace.scroller = { runHandler: function(title, top, bottom, height) { var i; var handlers = tiddlyspace.scroller.handlers; var tidEl = story.getTiddler(title); if(tidEl) { var topEl =$(tidEl).offset().top + 20;
if(top === false || (topEl > top && topEl < bottom)) {
var h = handlers[title];
for(i = 0; i < h.length; i++) {
h[i]();
}
tiddlyspace.scroller.clearHandlers(title);
}
} else {
tiddlyspace.scroller.clearHandlers(title);
}
},
clearHandlers: function(title) {
tiddlyspace.scroller.handlers[title] = [];
},
registerIsVisibleEvent: function(title, handler) {
tiddlyspace.scroller.handlers[title] = tiddlyspace.scroller.handlers[title] || [];
tiddlyspace.scroller.handlers[title].push(handler);
},
init: function() {
this.handlers = {};
this.interval = window.setInterval(function() {
var top = $(window).scrollTop(); var height =$(window).height();
var bottom = top + height;
var title;
for(title in tiddlyspace.scroller.handlers) {
if(title) {
tiddlyspace.scroller.runHandler(title, top, bottom, height);
}
}
}, 2000); // every 2 seconds check scroll position
}
};
tiddlyspace.scroller.init();

var followMacro = config.macros.followTiddlers = {
locale: {
noTiddlersFromFollowers: "None of the spaces you follow contain a tiddler with this name.",
errorMessage: "There was a problem retrieving tiddlers from the server. Please try again later."
},
init: function() {
followMacro.lookup = {};
},
followTag: "follow",
getHosts: function(callback) {
tweb.getStatus(function(status) {
callback(tweb.host, tiddlyspace.getHost(status.server_host, "%0"));
});
},
getBlacklist: function() {
return store.getTiddlerText("FollowTiddlersBlackList").split("\n");
},
handler: function(place, macroName, params, wikifier, paramString, tiddler) {
var args = paramString.parseParams("anon")[0];
var containingTiddler = story.findContainingTiddler(place).getAttribute('tiddler');
var title = (args.anon && args.anon[0]) || tiddler.fields["server.title"] || tiddler.title;
var tid = store.getTiddler(title);
var user = params[1] || false;
if(tid) {
followMacro.makeButton(place, {
url: "/search?q=title:%22" + encodeURIComponent(title) + "%22",
containingTiddler: containingTiddler,
blacklisted: followMacro.getBlacklist(), title: title, user: user,
args.follow[0] === 'false') ? false : true });
}
},
makeButton: function(place, options) { // this is essentially the same code in TiddlySpaceFollowingPlugin
var title = options.title;
var blacklisted = options.blacklisted;
var tiddler = store.getTiddler(title);
var btn = $('
').addClass("notLoaded").appendTo(place)[0]; if(blacklisted.contains(title)) {$(btn).remove();
return;
} else {
var user = options.user;
window.setTimeout(function() { // prevent multiple calls due to refresh
tiddlyspace.scroller.registerIsVisibleEvent(options.containingTiddler, function() {
var mkButton = function(followers, ignore) {
if(!followers && !ignore) {
$(btn).remove(); } else {$("").appendTo(btn);
var scanOptions = { url: options.url,
spaceField: options.spaceField || "bag", template: null, sort: "-modified",
callback: function(tiddlers) {
$(btn).removeClass("notLoaded"); followMacro.constructInterface(btn, tiddlers); } }; if(!ignore) { scanOptions.showBags = followMacro._getFollowerBags(followers); } scanOptions.hideBags = [tiddler.fields["server.bag"]]; scanMacro.scan(null, scanOptions, user); } }; if(options.consultFollowRelationship) { followMacro.getFollowers(mkButton); } else { mkButton([], true); } }); }, 1000); } }, constructInterface: function(container, tiddlers) { var txt = tiddlers.length; var className = txt > 0 ? "hasReplies" : "noReplies"; var el =$(story.findContainingTiddler(container));
$(container).empty().addClass(className); var btn =$("").addClass("followedTiddlers").text(txt).
click(function(ev) {
followMacro.followingOnClick(ev);
}).appendTo('
').appendTo(container)[0];
$.data(btn, "tiddlers", tiddlers); }, followingOnClick: function(ev) { var target = ev.target; var locale = followMacro.locale; var el =$('
')[0];
var popup = Popup.create(target,"div");
$(popup).addClass("taggedTiddlerList followList").click(function(ev) { // make it so only clicking on the document outside the popup removes the popup if(ev.target.parentNode != document) { ev.stopPropagation(); } }).append(el); var tiddlers =$.data(target, "tiddlers") || [];
scanMacro.template(el, tiddlers, "FollowTiddlersTemplate");
if(tiddlers.length === 0) {
$("
").text(locale.noTiddlersFromFollowers).appendTo(el); } Popup.show(); ev.stopPropagation(); return popup; }, _getFollowerBags: function(followers) { // XXX: private or not? return$.map(followers, function(name, i) {
return name != currentSpace ? "%0_public".format(name) : null;
});
},
// returns a list of spaces being followed by the existing space
var followersCallback = function(user) {
if(!user.anon) {
scanMacro.scan(null, {
url: "/search?q=bag:%0_public tag:%1 _limit:%2".format(user.name, followMacro.followTag, LIMIT_FOLLOWING),
spaceField: "title", template: null, cache: true,
callback: function(tiddlers) {
var followers = [];
for(var i = 0; i < tiddlers.length; i++) {
followers.push(tiddlyspace.resolveSpaceName(tiddlers[i].title));
}
callback(followers);
}
});
} else {
callback(false);
}
};
}
};

var scanMacro = config.macros.tsScan = {
init: function () {
this.scanned = {};
},
_tiddlerfy: function(jsontiddlers, options) {
var tiddlers = [];
var spaceField = options.spaceField || "bag"; // TODO: phase out use view types instead
$.each(jsontiddlers, function(i, t) { var use = false; if(!options.showBags || (options.showBags && options.showBags.contains(t.bag))) { use = true; } if(options.hideBags && options.hideBags.contains(t.bag)) { use = false; } if(use) { var spaceName = t[spaceField]; var tiddler = config.adaptors.tiddlyweb.toTiddler(t, tweb.host); tiddler.fields["server.space"] = tiddlyspace.resolveSpaceName(spaceName); tiddlers.push(tiddler); } }); return tiddlers; }, _scanCallback: function(place, jsontiddlers, options) { var locale = followersMacro.locale; var tiddlers = scanMacro._tiddlerfy(jsontiddlers, options); if(options.sort) { tiddlers = store.sortTiddlers(tiddlers, options.sort); } if(options.filter) { var _store = new TiddlyWiki(); config.lastStore = _store; for(var i = 0; i < tiddlers.length; i++) { var clone = tiddlers[i]; clone.title = tiddlyspace.getLocalTitle(clone.title, clone.fields['server.workspace']); _store.addTiddler(clone); } tiddlers = _store.filterTiddlers(options.filter); } if(place) {$(place).empty();
var list = $("
").appendTo(place)[0]; scanMacro.template(list, tiddlers, options.template); if(tiddlers.length === 0) {$("
").text(options.emptyMessage || locale.noone).appendTo(list);
$(list).addClass("emptyList"); } } if(options.callback) { options.callback(tiddlers); } }, constructSearchUrl: function(host, options) { if(options.url) { return options.url; } var inputs = options.searchValues; var tag = options.tag; var searchField = options.searchField || "title"; var searchQuery = []; for(var i = 0; i < inputs.length; i++) { searchQuery.push('%0:"%1"'.format(searchField, inputs[i])); } var query = searchQuery.join(" OR "); query = tag ? "(%0) AND tag:%1".format(query, tag) : query; query = options.query ? "%0;%1;".format(query, options.query) : query; query = options.fat ? "%0&fat=1".format(query) : query; return '%0/search?q=%1'.format(host, query); }, scan: function(place, options) { // TODO: make use of list macro with url filter var locale = followersMacro.locale; options.template = options.template ? options.template : "ScanTemplate"; followMacro.getHosts(function(host, tsHost) {$(place).text(followersMacro.locale.pleaseWait);
options = options ? options: {};
var url = scanMacro.constructSearchUrl(host, options);
if(options.cache && scanMacro.scanned[url]) {
var tiddlers = scanMacro.scanned[url].tiddlers;
var run = function(tiddlers) {
scanMacro._scanCallback(place, tiddlers, options);
};
if(tiddlers) {
run(tiddlers);
} else {
scanMacro.scanned[url].callbacks.push(run);
}
} else {
var callback = function(tiddlers) {
scanMacro._scanCallback(place, tiddlers, options);
};
if(scanMacro.scanned[url] && scanMacro.scanned[url].callbacks) {
scanMacro.scanned[url].callbacks.push(callback);
} else {
scanMacro.scanned[url] = {
callbacks: [callback]
};
}
ajaxReq({
url: url,
dataType: "json",
success: function(tiddlers) {
scanMacro.scanned[url].tiddlers = tiddlers;
var callbacks = scanMacro.scanned[url].callbacks;
while(callbacks.length > 0) {
callbacks.pop()(tiddlers);
}
},
error: function(xhr) {
$(place).empty();$("").addClass("annotation error").text(locale.error.format(xhr.status)).appendTo(place);
}
});
}
});
},
template: function(place, tiddlers, template) { // TODO: make use of list macro.
for(var i = 0; i < tiddlers.length; i++) {
var tiddler = tiddlers[i];
var item = $('
').appendTo(place)[0]; var spaceName = tiddler.fields["server.space"] || ""; var templateText = store.getTiddlerText(template).replace(/\$1/mg, spaceName);
wikify(templateText, item, null, tiddler);
}
},
getOptions: function(paramString, tiddler) {
var args = paramString.parseParams("name", null, true, false, true)[0];
var options = { query: false, sort: false, tag: false, template: false, showBags: args.show || false,
hideBags: args.hide || false, filter: false, spaceField: "bag", searchField: "title", fat: false,
emptyMessage: false };
for(var name in args) {
if(name != "name") {
if(name == "fat") {
options[name] = true;
} else {
options[name] = args[name][0];
}
}
}
// if user has set searchField to modifier, then use the modifiers value if available otherwise use searchValues.
var searchField = options.searchField;
var searchValues = args[searchField] ? args[searchField] : args.searchValues;
// if neither of those were used use the first parameter
var defaultValues = tiddler ? [ tiddler.title ] : [];
options.searchValues = searchValues ? searchValues : ( args.name ? [args.name[0]] : defaultValues);
return options;
},
handler: function(place, macroName, params, wikifier, paramString, tiddler) {
var container = $("
").addClass("scanResults resultsArea").appendTo(place)[0]; var options = scanMacro.getOptions(paramString, tiddler); scanMacro.scan(container, options); } }; var followersMacro = config.macros.followers = { locale: { loggedOut: "Please login to see the list of followers", noSupport: "We were unable to retrieve followers as your browser does not support following.", pleaseWait: "Please wait while we look this up...", error: "Error %0 occurred whilst retrieving data from server", noone: "None." }, handler: function(place, macroName, params, wikifier, paramString, tiddler) { var locale = followersMacro.locale; var args = paramString.parseParams("name", null, true, false, true)[0]; var username = args.name ? args.name[0] : false; var container =$('
').text(locale.pleaseWait).
appendTo(place)[0];
var followersCallback = function(user) {
if(user.anon) {
$("").text(locale.loggedOut).appendTo(container); } else { var options = scanMacro.getOptions(paramString);$.extend(options, {
url: "/search?q=title:@%0 OR title:%0 tag:%1 _limit:%2".
format(user.name, followMacro.followTag, LIMIT_FOLLOWING),
spaceField: "bag",
template: options.template ? options.template : "FollowersTemplate"
});
scanMacro.scan(container, options);
}
};
return !username ? followersCallback({ name: currentSpace }) : followersCallback({ name: username });
}
};

var followingMacro = config.macros.following = {
locale: {
noSupport: followersMacro.locale.noSupport,
error: followersMacro.locale.error,
noone: followersMacro.locale.noone
},
handler: function(place, macroName, params, wikifier, paramString, tiddler) {
var locale = followingMacro.locale;
var args = paramString.parseParams("name", null, true, false, true)[0];
var fat = args.fat ? true : false;
var username = args.name ? args.name[0] : false;
var container = $('
').text(locale.pleaseWait). appendTo(place)[0]; var followingCallback = function(user) { if(user.anon) {$("").text(locale.loggedOut).appendTo(container);
} else {
var options = scanMacro.getOptions(paramString);
$.extend(options, { url: "/search?q=bag:%0_public tag:%1 _limit:%2".format(user.name, followMacro.followTag, LIMIT_FOLLOWING), spaceField: "title", template: options.template ? options.template : "FollowingTemplate" }); scanMacro.scan(container, options); } }; return !username ? followingCallback({ name: currentSpace }) : followingCallback({ name: username }); } }; var linkedMacro = config.macros.linkedTiddlers = { handler: function(place, macroName, params, wikifier, paramString, tiddler) { var args = paramString.parseParams("anon")[0]; var title = params[0] || tiddler.fields["server.title"] || tiddler.title; var tid = store.getTiddler(title); var containingTiddler = story.findContainingTiddler(place).getAttribute('tiddler'); if(tid) { followMacro.makeButton(place, { spaceField: "recipe", url: "/bags/%0/tiddlers/%1/backlinks".format(tid.fields['server.bag'], encodeURIComponent(tid.title)), blacklisted: followMacro.getBlacklist(), title: title, containingTiddler: containingTiddler, user: params[1] || false, consultFollowRelationship: args.follow ? true : false }); } } }; if(config.options.chkFollowTiddlersIsLinkedTiddlers) { merge(config.macros.followTiddlers, config.macros.linkedTiddlers); config.shadowTiddlers.FollowTiddlersHeading = "These are the other tiddlers that link to this tiddler."; } })(jQuery); //}}} !!Parent page We have fixed on a definition of "half-dimensional sets" and now want to see [[whether we can use it to make the proof work|Is the shrinking neighbourhoods game likely to work for our purposes?]]. !Introduction One of the first things to do to get an idea of whether the new definition will work is to try to find an analogue of the argument in the trees set-up that all sets can be simultaneously lifted to sets that are decided after one move from each player. I have a reasonable idea of how to go about this, so the basic method I will use to find that analogue will be """GuessAndAdjust""". The object I am guessing is a lift that is analogous to the one that works for trees. (That one is described !An attempt Let me try to do the obvious thing. Let $$X\subset\Gamma^n$$ be a complexity structure. Define a complexity structure $$Y$$ to consist of all sequences of the form $$((x_1,S),x,x_3,x_4,\dots,x_n)$$, where $$S$$ is a minimal """I-winning""" set, $$x_1$$ is the first coordinate of at least one point that belongs to $$S$$, and $$x=(x_1,x_2,\dots,x_n)$$ is a point that belongs to $$S$$. Let $$\pi:Y\to X$$ be the map that takes the sequence $$((x_1,S),x,x_3,x_4,\dots,x_n)$$ to $$x$$. !!Is the lift just defined a Ramsey lift? The answer to this question is not obvious in advance, since with the shrinking-neighbourhoods game one can restrict the coordinates in any order. We want to show that if $$W$$ is a winning set in $$Y$$, then $$\pi(W)$$ is a winning set (for the same player) in $$X$$. ''Case 1.'' Let's start with the case where $$W$$ is a """I-winning""" set. Unlike in the trees case, there are some further subcases to consider, according to the order of restrictions that gives Player I a winning strategy for $$W$$. ''Subcase 1.1.'' Let's start with the case where the winning strategy for Player I begins with a restriction of the first coordinate. In this case, Player I chooses a minimal winning set $$S\subset X$$ and a first coordinate $$x_1$$ that is compatible with $$S$$, and plays the pair $$(x_1,S)$$. Player II now has two options. Either he can choose some $$x\in S$$ with first coordinate $$x_1$$, or he can choose some $$x_r$$ with $$r>2$$ such that there exists $$x\in S$$ with first coordinate $$x_1$$ and $$r$$th coordinate $$x_r$$. It cannot be an advantage to do the second, because in the first case Player II can determine the final sequence of the game, whereas in the second case he determines only one further coordinate. So without loss of generality he goes for the first option and chooses some $$x$$ compatible with $$(x_1,S)$$. If Player II does this, then the sequence $$((x_1,S),x,x_3,\dots,x_n)$$ must belong to $$W$$, since Player I is playing a winning strategy. Therefore, $$\pi(W)$$ contains all sequences $$x$$ that are compatible with $$S$$ and $$x_1$$. I now see that I have slipped up. It is not clear that $$\pi(W)$$ is a winning set for Player I, since for the winning set $$S$$ it may be better to restrict a different coordinate first, rather than the first coordinate. But that looks as though it is easy to fix. !A second attempt The game will be as before, except with one important modification. The complexity structure $$Y$$ consists of all sequences of the form $$y=(y_1,y_2,\dots,y_n)$$ with the following properties. Exactly one of the $$y_i$$ is an ordered pair of the form $$(S,\gamma_i)$$, where $$S$$ is a minimal """I-winning""" subset of $$X$$ and the first move of a winning strategy for $$S$$ for Player I is the specification $$x_i=\gamma_i$$. Also, exactly one $$y_j$$ takes the form of a point $$x\in S$$ such that $$x_i=\gamma_i$$. Finally, if $$h$$ is not $$i$$ or $$j$$, then $$y_h=x_h$$. Then $$\pi(y)=x$$. Now let us try again to prove that this works. We want to show that if $$W$$ is a winning set in $$Y$$, then $$\pi(W)$$ is a winning set (for the same player) in $$X$$. ''Case 1.'' Let's start with the case where $$W$$ is a """I-winning""" set. ''Subcase 1.1.'' Let's start with the case where the winning strategy for Player I begins by declaring that $$y_i$$ is an ordered pair of the form $$(S,\gamma_i)$$. Player II now has two options. Either he can choose some $$j\ne i$$ and some $$x\in S$$ with $$x_i=\gamma_i$$ and can declare that $$y_j=x$$, or he can choose some $$j\ne i$$ and declare that $$y_j=\gamma_j$$, where $$\gamma_j$$ is chosen in such a way that there exists $$x\in S$$ with $$x_i=\gamma_i$$ and $$x_j=\gamma_j$$. It cannot be an advantage to do the second, because if Player II can win after playing a move of the type $$y_j=\gamma_j$$, then there must be a sequence $$y\in W^c$$ such that $$y\in W^c$$, $$y_i=(S,\gamma_i)$$ and $$y_j=\gamma_j$$. Whatever that sequence is, Player II can fix the coordinate $$y_r$$ that is equal to some $$x\in X$$ and thereby guarantee a win after his first move. So without loss of generality he goes for the first option and chooses a specification of the form $$y_j=x$$. If Player II does this, then the sequence $$(x_1,x_2,\dots,x_{i-1},(S,\gamma_i),x_{i+1},\dots,x_{j-1},x,x_{j+1},\dots,x_n)$$ must belong to $$W$$, since Player I is playing a winning strategy. Therefore, $$\pi(W)$$ contains all sequences $$x$$ that are compatible with $$S$$ and the specification $$x_i=\gamma_i$$. This implies that $$\pi(W)$$ is a """I-winning""" subset of $$X$$. The reason is that $$S$$ is a """I-winning""" set with a winning strategy that begins with the specification $$x_i=\gamma_i$$. Since there is such a winning strategy, we can throw away any sequences that there might be in $$S$$ for which $$x_i\ne\gamma_i$$ and we will still have a winning set. (In fact, since we were assuming that $$S$$ is a minimal winning set, there are no such sequences, but this is an unimportant detail.) ''Subcase 1.2.'' Now I hit a problem. What if the winning strategy we're talking about for $$W$$ starts with a declaration of the form $$y_i=x$$ for some $$x\in X$$? That's perfectly possible: it just requires that one of the other specifications will be of the form $$y_j=(S,\gamma_j)$$, where $$S$$ is a minimal """I-winning""" subset of $$X$$ that contains $$x$$ and $$\gamma_j=x_j$$. The reason that's a problem is that that allows $$W$$ to be $$\pi^{-1}(\{x\})$$, so it allows $$\pi(W)$$ to be $$\{x\}$$, which is obviously not a winning set (in general). The difficulty I seem to be up against is that, unlike in the case of trees and games, I can't assume that moves come in any particular order. So I need to make my definitions more symmetric somehow. !A third attempt I have an idea that has a slightly annoying feature but may nevertheless be quite helpful. The idea is that instead of the two special coordinates being of completely different forms $$y_i=(S,\gamma_i)$$ and $$y_j=x$$, which leads to problems because $$y_j=x$$ narrows the image down far too much if you play it first, we should make one special coordinate be of the form $$y_i=(\sigma,\gamma_i)$$ for some """I-strategy""" $$\sigma$$ for the $$X$$ game and the other one be of the form $$y_j=(\tau,\gamma_j)$$ for some """II-strategy""" $$\tau$$. We also need a consistency condition that $$\sigma\circ\tau$$ <<slider chkDefinitionOfSigmaTau "Composition of two strategies" "What's that?" "Reminder of definition">> is a sequence $$x$$ such that $$x_i=\gamma_i$$ and $$x_j=\gamma_j$$. The elements of $$Y$$ are therefore sequences $$y=(y_1,\dots,y_n)$$ such that for some $$i$$ and $$j$$, $$y_i$$ and $$y_j$$ are as above, while for all other $$r$$, $$y_r=x_r$$, where $$x=\sigma\circ\tau$$. The annoying feature is that I think that if $$W$$ is a """I-winning""" subset of $$Y$$, the best we will be able to say about $$\pi(W)$$ is that it is either a """I-winning""" subset of $$X$$ or a """II-winning""" subset of $$X$$. But I think I can probably live with that. I'll call a set //winning// if it is either """I-winning""" or """II-winning""". My Ramsey property will be that for every set $$A$$, either $$A$$ or $$A^c$$ contains a winning subset. And the property of Ramsey lifts will be that they take winning subsets to winning subsets -- but not necessarily for the same player. Without checking carefully, I can't rule out that there will still be some snag here. But at least I've made things more symmetrical, thereby doing my best to avoid the problems I've had so far. So let me try once again to get the proof to work. As above, $$W$$ is a winning set in $$Y$$. The place where the snag is most likely to occur is if Player I's first move in a winning strategy for $$W$$ is of the form $$y_j=(\tau,\gamma_j)$$, where $$\tau$$ is a strategy for Player II in the shrinking-neighbourhoods game on $$X$$. If Player II wants to follow that with a declaration of the form $$y_i=(\sigma,\gamma_i)$$ for some """I-strategy""" $$\sigma$$, then $$i$$ and $$\gamma_i$$ must be chosen in such a way that the response of $$\tau$$ to the opening move $$x_i=\gamma_i$$ is the move $$x_j=\gamma_j$$. Is this problematic? One thing we know is that such an $$i$$ and $$\gamma_i$$ do exist, since otherwise the move $$y_j=(\tau,\gamma_j)$$ would be illegal. Unfortunately, it //is// problematic. If Player I can win by playing this strategy, then Player I has a winning strategy for the set of sequences $$y\in W$$ such that $$\pi(y)_j=\gamma_j$$ and $$y$$ is consistent with the """II-strategy""" $$\tau$$. But is that true? How might we try to devise a winning strategy for this set? The first move will have to be the declaration $$x_i=\gamma_i$$. Suppose that Player II responds with the move $$x_h=\gamma_h$$, while the actual response of $$\tau$$ to this declaration would be $$x_j=\gamma_j$$. I think that in that case Player I could play the declaration $$x_j=\gamma_j$$ that Player II "should have made", so we're not quite dead yet. Where it becomes more problematic is if Player II responds with $$x_j=\gamma_j'$$ for some $$\gamma_j'$$ not equal to $$\gamma_j$$. Then I'm not sure I can see how Player I can hope to force a sequence in $$\pi(W)$$. !A provisional fourth attempt The problem I'm facing can be described as follows: I am trying to find a lift for a non-symmetric Ramsey theorem (that is, a theorem that says that either $$A$$ contains a set of one kind or $$A^c$$ contains a set of another kind), but the game is symmetric, in the sense that the outcome does not depend on the order in which the moves were played, so there doesn't seem to be a way of allowing two different kinds of first move without allowing Player I to play the kind of first move that was designed for Player II. If we had a //symmetric// Ramsey theorem, then I think this problem would not arise. Actually, as I write I have had another idea, which is a modification to the game to make it less symmetrical. I think I'll try that first. !A fifth attempt Let's assume that $$n$$ is even. The game is as before, except that Player I is only allowed to specify coordinates between 1 and $$n/2$$, while Player II is only allowed to specify coordinates between $$n/2+1$$ and $$n$$. Definitions of concepts like """I-winning""" sets and Ramsey lifts now apply to this game. Now let me try to define a Ramsey lift $$\pi:Y\to X$$. I'll let $$Y$$ consist of all sequences of the form $$y=(y_1,\dots,y_n)$$ with the following properties: #for exactly one $$i$$ between 1 and $$n/2$$, we have $$y_i=(\sigma,\gamma_i)$$, where $$\sigma$$ is a """Player-I""" strategy for $$X$$ with first move $$x_i=\gamma_i$$; #for exactly one $$j$$ between $$n/2+1$$ and $$n$$, we have $$y_j=(\tau,\gamma_j)$$, where $$\tau$$ is a """Player-II""" strategy for $$X$$, and $$(\sigma\circ\tau)_j=\gamma_j$$; #$$y_r=(\sigma\circ\tau)_r$$ for every $$r$$ not equal to either $$i$$ or $$j$$. The map $$\pi$$ takes a sequence $$y$$ as just described to the sequence $$\sigma\circ\tau$$. I won't worry about it now, but I think I could just as well have let $$y_i=\sigma$$ and $$y_j=\tau$$, since that gives rise to the same sequence $$\sigma\circ\tau$$. Another observation I will worry about, however. I think that now that I have not allowed Player I to specify a strategy designed for Player II, I no longer need Player II to specify the entire strategy $$\tau$$ -- he could just as well go back to specifying a sequence $$x$$ compatible with $$\sigma$$. That is slightly simpler, so I'll assume that it's what happens. In fact, to hell with it, I'll rewrite the lot. #For exactly one $$i$$ between 1 and $$n/2$$, we have $$y_i=\sigma$$, where $$\sigma$$ is a """Player-I""" strategy for $$X$$ such that the first move consists of a specification of $$x_i$$. #For exactly one $$j$$ between $$n/2+1$$ and $$n$$, we have $$y_j=x$$, where $$x$$ is an element of $$X$$ that could arise during a run of the game with Player I playing with the strategy $$\sigma$$ and Player II responding with a specification of $$x_j$$. #$$y_r=x_r$$ for every $$r$$ not equal to either $$i$$ or $$j$$. The map $$\pi$$ takes a sequence $$y$$ as just described to the sequence $$x$$. Now I want to prove that this is a Ramsey lift. ''Case 1. $$W$$ is a """I-winning""" subset of $$Y$$.'' ''Subcase 1.1. Player I's first move is of the form $$y_i=(\sigma,\gamma_i)$$.'' Since this is a winning strategy for Player I for getting into $$W$$, it must be that if Player II plays a move of the form $$y_j=x$$, then Player I wins. Since Player II can play any $$x$$ that is consistent with $$\sigma$$, the image $$\pi(W)$$ contains all sequences consistent with $$\sigma$$. Therefore, $$\sigma$$ is a winning strategy for $$\pi(W)$$. ''Subcase 1.2. Player I's first move is of the form $$y_i=\gamma_i$$.'' If Player I does this, then Player II can play a move of the form $$y_j=x$$, provided that $$x_i=\gamma_i$$. Therefore, $$\pi(W)$$ contains all sequences $$x$$ such that $$x_i=\gamma_i$$, so it is trivial that Player I has a winning strategy for $$\pi(W)$$. ''Case 2. $$W$$ is a """II-winning""" subset of $$Y$$.'' This tells us in particular that for every move Player I might make of the form $$y_i=\sigma$$, there is some response either of the form $$y_j=x$$ or of the form $$y_r=\gamma_r$$ that leads to a win for Player II. Either way, there is some sequence $$x\in\pi(W)$$ consistent with Player I playing the strategy $$\sigma$$. It follows that Player I does not have a winning strategy for $$\pi(W)^c$$, so by finite determinacy Player II has a winning strategy for $$\pi(W)$$. !Conclusion I think I've got there at last. The result of this is a simple adaptation to complexity structures of the trivial lift that works in the tree case. Since there are doubly exponentially many strategies, this trivial lift is, as I wanted, very large. A final observation is that if $$\pi:Y\to X$$ is the lift just described, and $$A\subset X$$, then $$\pi^{-1}(A)$$ is equal to the set of $$y$$ such that some coordinate $$y_j$$ is equal to some $$x\in A$$. Therefore, it is a union of basic sets, which makes it a 1-open set in $$Y$$. If we want a set that is both 1-open and 1-closed, we can repeat the process to make $$A^c$$ a 1-open set (using the fact that lifts preserve 1-openness). [[Return to parent page|Is the shrinking neighbourhoods game likely to work for our purposes?]] /*** |''Name:''|MathJaxPlugin| |''Description:''|Enable LaTeX formulas for TiddlyWiki| |''Version:''|1.0.1| |''Date:''|Feb 11, 2012| |''Source:''|http://www.guyrutenberg.com/2011/06/25/latex-for-tiddlywiki-a-mathjax-plugin| |''Author:''|Guy Rutenberg| |''License:''|[[BSD open source license]]| |''~CoreVersion:''|2.5.0| !! Changelog !!! 1.0.1 Feb 11, 2012 * Fixed interoperability with TiddlerBarPlugin !! How to Use Currently the plugin supports the following delemiters: * """$$""".."""$$""" - Inline equations * """$$""".."""$$""" - Displayed equations * """$""".."""$""" - Displayed equations !! Demo This is an inline equation $$P(E) = {n \choose k} p^k (1-p)^{ n-k}$$ and this is a displayed equation: $J_\alpha(x) = \sum_{m=0}^\infty \frac{(-1)^m}{m! \, \Gamma(m + \alpha + 1)}{\left({\frac{x}{2}}\right)}^{2 m + \alpha}$ This is another displayed equation $$e=mc^2$$ !! Code ***/ //{{{ config.extensions.MathJax = { mathJaxScript : "http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML", // uncomment the following line if you want to access MathJax using SSL // mathJaxScript : "https://d3eoax9i5htok0.cloudfront.net/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML", displayTiddler: function(TiddlerName) { config.extensions.MathJax.displayTiddler_old.apply(this, arguments); MathJax.Hub.Queue(["Typeset", MathJax.Hub]); } }; jQuery.getScript(config.extensions.MathJax.mathJaxScript, function(){ MathJax.Hub.Config({ extensions: ["tex2jax.js"], "HTML-CSS": { scale: 100 } }); MathJax.Hub.Startup.onload(); config.extensions.MathJax.displayTiddler_old = story.displayTiddler; story.displayTiddler = config.extensions.MathJax.displayTiddler; }); config.formatters.push({ name: "mathJaxFormula", match: "\\\\\$|\\\\|\\\\\$$", //lookaheadRegExp: /(?:\\\[|\$$((?:.|\n)*?)(?:\\$|$$)/mg, handler: function(w) { switch(w.matchText) { case "\$": // displayed equations this.lookaheadRegExp = /\\\[((?:.|\n)*?)(\\$)/mg; break; case "$$": // inline equations this.lookaheadRegExp = /\$\$((?:.|\n)*?)(\$\$)/mg; break; case "\$$": // inline equations this.lookaheadRegExp = /\\\(((?:.|\n)*?)(\\$$)/mg; break; default: break; } this.lookaheadRegExp.lastIndex = w.matchStart; var lookaheadMatch = this.lookaheadRegExp.exec(w.source); if(lookaheadMatch && lookaheadMatch.index == w.matchStart) { createTiddlyElement(w.output,"span",null,null,lookaheadMatch[0]); w.nextMatch = this.lookaheadRegExp.lastIndex; } } }); //}}} /*{{{*/ body { background: none; font-family: "Helvetica Neue", Helvetica, Arial; } h1, h2, h3, h4, h5 { color: black; border-bottom: none; } .tiddler .toolbar a:hover, .tiddler .toolbar a { border: none; background: none; } #sidebar { position: relative !important; width: 250px !important; float: right; margin: 0 0 25px 0; } #sidebar h1 { padding: 0 0 3px 0; font-size: 18px; } #sidebar li { border-top: 1px dotted #CCC; } #sidebar li a { font-size: 13px; font-weight: normal; padding: 2px 0 2px 15px; display: inline-block; } #sidebarTabs ul .listLink img, #sidebarTabs ul .listLink a { display: inline; } .searchButton { display: none; } #contentWrapper { width: 900px; margin: 30px auto 140px; padding: 30px 30px 0; background: white; background: rgba(255, 255, 255, 0.88); -webkit-border-radius: 6px; -moz-border-radius: 6px; border-radius: 6px; } .header { float: left; width: 900px; border-bottom: 1px dotted #CCC; margin: 0; background: none; } .header h1 { margin-top: 0px; color: [[ColorPalette::PrimaryMid]]; font-size: 60px; font-weight: 600; text-decoration: none; border-bottom: none; letter-spacing: -2px; text-rendering: optimizeLegibility; background: none; } .header h2 { font-size: 18px; font-weight: 200; padding: 12px 4px 0 0; color: black; border-bottom: none; } h1, h2 { text-decoration: none; border-bottom: none; } #navBar { float: right; padding: 12px 0 0; } #navBar ul { height: 50px; margin-bottom: 2px; list-style: none; display: inline; list-style-type: square; } #navBar ul li { display: inline !important; list-style: none; } #navBar li a { font-size: 18px; font-weight: 400; display: inline-block !important; padding: 15px; border-bottom: none; } #navBar li a:hover { color: #04B; } #tiddlerDisplay { width: 620px; float: left; border-right: 1px dotted #CCC; padding: 0 0 30px 0; min-height: 420px; overflow: hidden; } #displayArea { margin: 0; } .title { font-family: Georgia, serif; font-size: 28px; margin: 30px 0 10px 0; font-weight: normal; line-height: 32px; border-bottom: 1px dotted black; text-decoration: none; color: black; display: inline-block; } .subtitle { font-size: 0.9em; } .subtitle ul, .subtitle li { display: inline; padding-left: 0px; } .tiddler .viewer { clear: both; } /*}}}*/  ''Definition.'' A //complexity structure// is a subset $$X$$ of a set $$\Gamma^n$$. Given such a structure, the //basic sets// are all sets of the form $$\{x\in X:x_i\in\Delta\}$$ for some $$1\leq i\leq n$$ and some subset $$\Delta$$ of $$\Gamma$$. ''Definition.'' A //lift// of a complexity structure $$X$$ is a complexity structure $$X'$$ and a map $$\pi:X'\to X$$ such that for every $$x',y'\in X'$$ and every $$1\leq i\leq n$$, if $$x_i'=y_i'$$ then $$\pi(x')_i=\pi(y')_i$$. In other words, the $$i$$th coordinate of $$\pi(x')$$ depends only on the $$i$$th coordinate of $$x'$$. These definitions are taken from [[the parent page of this page|Can we find an analogue of Martin's theorem by thinking about more general Ramsey properties?]] !!Parent page We want to [[find a lift that's modelled on Martin's lift|Can we find a lift that is modelled on Martin's lift from closed games to open games?]] !Introduction The very simplest version of the problem I'd like to solve is this. I have a subset $$A=\{x\in X:x_i\in\Delta_i\}$$ of a complexity structure $$X\in\Gamma_1\times\dots\times\Gamma_n$$, with $$i$$ in the first half of the coordinates. I also have $$j$$ in the second half of the coordinates. I want to add extra information so as to obtain a Ramsey lift $$\pi:Y\to X$$ such that the $$j$$th coordinate of $$y$$ tells you whether $$\pi(y)\in A$$. An initial attempt, made [[here|How easy is it to lift a 2-basic set to a 1-basic set?]], was this. Let $$Y$$ be the set of sequences $$y=(y_1,\dots,y_n)$$ with the following properties. #$$y_j$$ is a pair of the form $$(x_j,\epsilon_j)$$ with $$\epsilon_j\in\{0,1\}$$. #Every other $$y_r$$ is of the form $$x_r$$. #The sequence $$x=(x_1,\dots,x_n)$$ belongs to $$X$$. #$$x\in A$$ if and only if $$\epsilon_j=1$$. The map $$\pi$$ takes $$y$$ to $$x$$. The extra information is the single bit $$\epsilon_j$$, which tells us in the most direct way imaginable whether $$\pi(y)\in A$$.
 After a good night's sleep, I've realized that the above approach won't work. I've recorded the reason for this at the end of [[the grandparent page of this one|How easy is it to lift a 2-basic set to a 1-basic set?]]. @@Please do not modify this tiddler; it was created automatically upon space creation.@@ /*** |''Name''|TiddlerEditablePlugin| |''Description''|Any elements with a tiddler attribute set and a class tiddlerEditable will allow in place editing| |''Version''|0.3.5| ***/ //{{{ (function($) {

var extension = config.extensions.tiddlerEditable = {
init: function() {
return;
}
$(".tiddlerEditable, .tiddlerEditable").attr("title", "Double click on this to edit.").dblclick(function(ev) { var target = ev.target; var title =$(target).attr("tiddler");
if(!title) {
title = $("[tiddler]", target).attr("tiddler"); tidEl =$("[tiddler]", target)[0];
} else {
tidEl = target;
}
if(!title) {
return;
}
var tiddler = store.getTiddler(title);
var type = tiddler && tiddler.fields['server.content-type'] ? tiddler.fields['server.content-type'] : false;
$(tidEl).empty(); var binary; if(type && type.indexOf("text/") !== 0) { binary = true; } if(!binary) {$("<textarea />").focus(function(ev) {
$(ev.target).data("dirty", true); }).val(store.getTiddlerText(title)).appendTo(target); } else { wikify("<<binaryUploadPublic title:\"%0\">>".format(title), tidEl) } ev.preventDefault(); return false; }).mouseover(function(ev) {$(ev.target).addClass("hover")
}).mouseout(function(ev) {
$(ev.target).removeClass("hover") }); } };$(window).click(function(ev) {
var tag = ev.target.tagName;
if(tag == "TEXTAREA" || tag == "FORM" || tag == "INPUT") {
return;
} else {
var tiddlers = [];
var textareas = $(".tiddlerEditable textarea"); textareas.each(function(i, el) { var val =$(el).val();
var c = el.parentNode;
var title = $(c).attr("tiddler"); var tiddler = store.getTiddler(title); if($(el).data("dirty")) {
tiddler.text = val;
if(config.filterHelpers) {
var is = config.filterHelpers.is;
if(is && !is.local(tiddler)) {
delete tiddler.fields['server.etag'];
delete tiddler.fields['server.bag'];
delete tiddler.fields['server.page.revision'];
merge(tiddler.fields, config.defaultCustomFields);
}
}
tiddler = store.saveTiddler(tiddler);
tiddlers.push(tiddler);
} else {
$(c).empty(); wikify(tiddler.text, c, null, tiddler); } }); var forms =$(".tiddlerEditable form");
if(forms.length > 0) {
refreshDisplay();
}
if(tiddlers.length > 0) {
autoSaveChanges(null, tiddlers);
}
}
});
_refreshPageTemplate = refreshPageTemplate;
refreshPageTemplate = function() {
_refreshPageTemplate.apply(this, arguments);
extension.init();
}
_refreshDisplay = refreshDisplay;
refreshDisplay = function() {
_refreshDisplay.apply(this, arguments);
extension.init();
}

var r = config.macros.image._renderBinaryImageTiddler;
config.macros.image._renderBinaryImageTiddler = function(place, tiddler) {
$(place).attr("tiddler", tiddler.title); return r.apply(this, arguments); } window.setTimeout(function() { extension.init(); }, 1000); })(jQuery); //}}} (function() { var getCSRFToken = function(window) { // XXX: should not use RegEx - cf. // http://www.quirksmode.org/js/cookies.html // https://github.com/TiddlySpace/tiddlyspace/commit/5f4adbe009ed4bda3ce39058a3fb07de1420358d var regex = /^(?:.*; )?csrf_token=([^(;|$)]*)(?:;|$)/; var match = regex.exec(document.cookie); var csrf_token = null; if (match && (match.length === 2)) { csrf_token = match[1]; } return csrf_token; }; if (typeof config !== 'undefined' && config.extensions && config.extensions.tiddlyspace && config.extensions.tiddlyspace.getCSRFToken === null) { config.extensions.tiddlyspace.getCSRFToken = getCSRFToken; } else { window.getCSRFToken = getCSRFToken; } })(window); <svg xmlns="http://www.w3.org/2000/svg" xmlns:xl="http://www.w3.org/1999/xlink" version="1.1" viewBox="434 218 68 68" width="30" height="30"> <g stroke="none" stroke-opacity="1" stroke-dasharray="none" fill="none" fill-opacity="1"> <g> <path d="M 478.39694 232.53705 L 478.39694 232.53705 C 477.1145 231.85132 475.77875 231.30147 474.41058 230.88734 L 474.41058 218.24994 L 461.58942 218.24994 L 461.58942 230.88734 C 460.22125 231.30147 458.8855 231.85132 457.60306 232.53705 L 448.66824 223.60214 L 439.6022 232.66814 L 448.53717 241.60304 C 447.8515 242.8854 447.30157 244.22116 446.88745 245.58936 L 434.25 245.58936 L 434.25 258.41052 L 446.88745 258.41052 C 447.30157 259.77869 447.8515 261.11447 448.53717 262.39688 L 439.6022 271.33173 L 448.66824 280.3978 L 457.60306 271.46283 C 458.8855 272.14862 460.22125 272.69846 461.58942 273.11252 L 461.58942 285.74988 L 474.41058 285.74988 L 474.41058 273.11252 C 475.77875 272.69846 477.1145 272.14862 478.39694 271.46283 L 487.33176 280.3978 L 496.39767 271.33173 L 487.46286 262.39688 C 488.14853 261.11447 488.69836 259.77869 489.11255 258.41052 L 501.74988 258.41052 L 501.74988 245.58936 L 489.11255 245.58936 C 488.69836 244.22116 488.14853 242.8854 487.46286 241.60304 L 496.39767 232.66814 L 487.33176 223.60214 Z M 475.3328 244.66714 C 479.3825 248.71698 479.3825 255.2829 475.3328 259.33273 C 471.28296 263.3826 464.71704 263.3826 460.66724 259.33273 C 456.61737 255.2829 456.61737 248.71698 460.66724 244.66714 C 464.71704 240.61734 471.28296 240.61734 475.3328 244.66714" fill="#111" class="glyph"/> </g> </g> </svg> !!Parent page We are trying to [[find a good generalization of the notion of a strategic subtree|What two classes of sets could serve as a "symmetric analogue" of the classes of strategic subtrees for Player I and Player II?]]. !Introduction I think I am looking for a definition with the following properties. *The definition applies to a subset $$Z$$ of a finite metric space $$X$$ for which all distances are integers. *A set $$Z$$ is half-dimensional if it is non-empty and if for every $$z\in Z$$ and every $$d$$, the number of points of $$Z$$ within a distance $$d$$ from $$z$$ is at least $$\phi(z,d,X)$$. That is, it is bounded below by some number that is defined in terms of $$d$$ and of how $$z$$ sits inside the metric space $$X$$. *Two half-dimensional sets must have non-empty intersection. *If $$A$$ is any subset of $$X$$, then either $$A$$ or $$A^c$$ contains a half-dimensional set. !A strategy for choosing the definition One way we might try to do this is to make the definition as strong as possible subject to the Ramsey property holding (the stronger the conditions we put on the set, the less likely the Ramsey property is to hold). Another is to make it as weak as possible subject to the intersection property holding (the weaker the conditions, the more likely it is that we will be able to find two sets that satisfy the conditions but don't intersect). Of these, the first looks more promising I think. Two quick remarks while I'm at it. One is that I have only a rather vague idea of why I am trying to formulate a definition with these properties. Or rather, I have no idea why a definition with these properties should help me find a non-trivial consequence of low circuit complexity: the reason I want them is to keep as closely analogous as I can to the proof of Martin's theorem, in the hope that that will make the miracle I am hoping for as likely as possible to occur. A second remark is that the combination of the intersection property and the Ramsey property is interestingly reminiscent of the defining properties of an ultrafilter. I don't have any suggestion about what to do with that remark, but it is somehow encouraging. How might we prove the intersection property? In the tree case, balls have the nice property that if you take any two of them, then either they are disjoint or one is contained in the other. As a result, the ball of radius $$r$$ can be partitioned into balls of radius $$r-1$$. In a more general metric space, that is no longer the case. Nevertheless, let us try to use the proof for the tree case as a guide. There we have that if the radius of the space is $$n$$, then a set is "half-dimensional" if it is "half-dimensional" inside at over half the balls of radius $$n-1$$. So if we have two half-dimensional sets, there exists a ball of radius $$n-1$$ inside which they are both still half-dimensional, and by induction we are done. (The precise details are not too important -- the point is that that's roughly what the argument looks like.) The Ramsey property can be also be proved by a simple inductive argument. (Again, the details are not too important: for instance, for now I am ignoring technical problems that arise if e.g. the number of balls of radius $$r-1$$ inside a ball of radius $$r$$ is even.) To get a feel for the difficulty we face in generalizing this to a wider class of finite metric spaces, let us consider the case of $$\{0,1\}^n$$. There are two differences that look significant. #Balls do not have to be either nested or disjoint. #The ball of radius $$r-1$$ about a point may be almost all of the ball of radius $$r$$ about that point. The second property happens when $$r$$ is approximately $$n/2$$ or greater. I don't know how problematic the second difference is, but one way we might consider reducing its effect is not to consider all possible radii, but rather a sequence of radii that guarantee that the balls get significantly bigger (in cardinality) as you progress along the sequence. However, this would not help all that much with the first difference, since the measure of a Hamming ball $$B$$ of radius $$r$$ is concentrated on its boundary, so unless $$s$$ is a lot smaller than $$r$$, a typical ball of radius $$s$$ that intersects $$B$$ does so in about half its measure. Suppose that in our inductive argument for the intersection property we have got to the point of saying that our two half-dimensional sets are half-dimensional in some ball $$B$$. All we really need from that is a probability measure $$\mu_B$$ on the balls of radius one step down in the sequence of radii such that for both half-dimensional sets the measure of the smaller balls inside which they are half-dimensional is greater than 1/2. So perhaps one could weight the smaller balls by how much they intersect $$B$$, or something like that. I feel at this point as though I have a rough idea of what a definition could look like, but that there are choices to make that cannot be made until I've thought about how the resulting definition might be used in the eventual proof. The main property I'm looking for of a good definition is that the condition, *For every $$F\in\mathcal{F}(Y)$$, $$\pi(F)$$ contains a set in $$\mathcal{F}(X)$$. should place a restriction on lifts that is strong enough to rule out very simple lifts such as the one [[defined here|How large an alphabet do we need to make a set basic?]], should not be so strong that sets of low circuit complexity cannot be lifted efficiently, and should be strong enough that arbitrary sets //cannot// be lifted efficiently. For now I want to get a feel for whether there is the slightest hope that some reasonable class of "half-dimensional sets" could do the job. A preliminary thing to worry about is whether there is //any// reasonable definition that is likely to rule out boringly trivial lifts such as the one [[defined here|How large an alphabet do we need to make a set basic?]]. [[TryWeakerQuestion|Is it easy to Ramsey-lift an arbitrary set to a simple set?]]
 It seems that there could be. Here are two more questions I want to know the answers to. Is there likely to be at least //some// lift that works for an arbitrary set? That is, is there a natural lift that we can regard as our "trivial upper bound"? [[ClarifyConcept|Can all sets be Ramsey lifted?]] An important thing to worry about, since it seems to be the thing that is most likely to go wrong, is whether lifting the parity function is just as hard as lifting a random function. [[TryWeakerQuestion|Can the parity function be efficiently Ramsey lifted?]]
 Another question that's been bugging me for some time is this: is there a good analogue of the """Gale-Stewart""" theorem? The reason that is important is that Martin's proof can be seen as a clever way of applying the """Gale-Stewart""" theorem transfinitely many times, and that is where the work happens. Therefore, if we want a finitary analogue of Martin's theorem, it would be good to decide what the analogous work is. [[ClarifyConcept|What would be a good analogue of the Gale-Stewart theorem?]]
 While writing [[this page|What is the difference between this set-up and the invariant game?]] I thought of a possible definition for half-dimensional subsets, at least of $$\{0,1\}^n$$ and with luck of more general complexity structures. So I want to explore that. [[LookForSomethingMoreSpecific|Can we use a DAG picture to define half-dimensional sets?]]   ''Definition.'' A //complexity structure// is a subset $$X$$ of a set $$\Gamma^n$$. Given such a structure, the //basic sets// are all sets of the form $$\{x\in X:x_i\in\Delta\}$$ for some $$1\leq i\leq n$$ and some subset $$\Delta$$ of $$\Gamma$$. ''Definition.'' A //lift// of a complexity structure $$X$$ is a complexity structure $$X'$$ and a map $$\pi:X'\to X$$ such that for every $$x',y'\in X'$$ and every $$1\leq i\leq n$$, if $$x_i'=y_i'$$ then $$\pi(x')_i=\pi(y')_i$$. The condition here is saying that the $$i$$th coordinate of $$\pi(x')$$ depends only on the $$i$$th coordinate of $$x'$$. These definitions are taken from [[the parent page of this page|Can we find an analogue of Martin's theorem by thinking about more general Ramsey properties?]]. !!Parent page We are looking into the question of [[whether we can imitate Martin's proof and then make it more efficient by an iterative procedure|Can we find an efficient lift by imitating Martin's proof and using an iterative procedure?]]. !Introduction Our iteration will start with the following "trivial" auxiliary game. $$Y$$ will consist of sequences of the form $$((\gamma_1,W),(\gamma_2,W),\dots,(\gamma_{n/2},W),(\gamma_{n/2+1},\bullet),\dots,(\gamma_n,\bullet))$$, with the following properties. #$$W=X$$ (and is therefore a winning subset of $$X$$ for Player I). #$$\bullet$$ is either $$A$$, if $$A$$ is a winning subset for Player II, or a set of coordinate restrictions of the form $$x_i\in\Gamma_i$$ (which are consistent with $$W$$) that guarantee that a sequence does not belong to $$A$$. #If $$\bullet$$ is the set $$A$$, then the sequence $$x=(\gamma_1,\dots,\gamma_n)$$ belongs to $$A$$. If it is a set of coordinate restrictions, then $$x$$ obeys those specifications. This lifted game is so trivial it may even be a bit confusing. But it isn't supposed to do anything interesting other than start an iteration precisely because it doesn't yet help us. !What is the next step of the iteration? To answer this, we'll need to try to run Martin's proof and see where we get stuck. So let $$W$$ be a winning set for Player I in the above game and let $$\sigma$$ be a winning strategy for Player I to get into $$W$$. We now need to devise a strategy for Player I in the original game. She can start by playing the move $$(x_i,X)$$ that is dictated by $$\sigma$$ in the auxiliary game. But now we run into a problem. Player II can't make a legal move unless either $$A$$ is a winning subset for Player II or there is a set of trivial coordinate restrictions that don't actually restrict anything but nevertheless guarantee that $$x\in A^c$$. The second possibility can happen only if $$A$$ is empty. But what if $$A$$ is neither empty nor a win for Player II? It must be possible for Player II to do something. What kind of coordinate restriction would allow Player II to guarantee that $$x\in A^c$$? Since $$A$$ is 1-closed, the answer to this is fairly easy: a restriction of the form $$x_i\notin\Delta_i$$, where $$A$$ is the set $$\{x:\forall i\ x_i\in\Delta_i\}$$. So let's make that adjustment. The lift now looks like this. $$Y$$ will consist of sequences of the form $$((\gamma_1,W),(\gamma_2,W),\dots,(\gamma_{n/2},W),(\gamma_{n/2+1},\bullet),\dots,(\gamma_n,\bullet))$$, with the following properties. #$$W=X$$ (and is therefore a winning subset of $$X$$ for Player I). #$$\bullet$$ is either $$A$$, if $$A$$ is a winning subset for Player II, or a coordinate restriction of the form $$x_i\notin\Delta_i$$ (which is consistent with $$W$$), where $$A=\{x:\forall i\ x_i\in\Delta_i\}$$. #If $$\bullet$$ is the set $$A$$, then the sequence $$x=(\gamma_1,\dots,\gamma_n)$$ belongs to $$A$$. If it is a coordinate restriction, then $$x$$ obeys that restriction. !Does that work? Of course not, but let's see what goes wrong. Let $$W$$ be a winning set for Player I in the above game and let $$\sigma$$ be a winning strategy for Player I to get into $$W$$. We now need to devise a strategy for Player I in the original game. She can start by playing the move $$x_i=\gamma_i$$, where $$(x_i,X)$$ is the move dictated by $$\sigma$$ in the auxiliary game. Now Player II plays $$x_j=\gamma_j$$ and Player I needs to decide what to do next. Martin would suggest defining $$U$$ to be the set of restrictions that are consistent with Player I's initial quasistrategy and result in positions from which all sequences you can get to belong to $$A^c$$. In this case, that makes $$U$$ the set of all possible restrictions of the form $$x_i\notin\Delta_i$$ (since they all have the required property and they are the only ones we are allowing). The proof then says that either Player I should play (in $$X$$) a winning strategy for getting to somewhere in $$U$$ or, if that is not possible, she should regard Player II as playing the canonical quasistrategy for //avoiding// $$U$$. So we need that canonical quasistrategy to be an option for Player II. Or rather, we need the corresponding winning set to be an option. Now let's switch to Player II's strategies. In this case, if $$Z$$ is a winning set for Player II (in $$Y$$) and $$\sigma$$ is a winning strategy for $$Z$$, then the Martin-like thing to do is to let Player I play $$x_i=\gamma_i$$ in the original game and then define $$U$$ to be the set of sets of restrictions that Player II might play in response to a move of the form $$(\gamma_i,W)$$ in the auxiliary game. So far the only $$W$$ we are allowing Player I to play is $$X$$ itself, and we aren't allowing Player II to do more than one restriction, which has to be of the form $$x_i\notin\Delta$$. So $$U$$ is a singleton that consists of whichever restriction of that form $$\sigma$$ chooses in response to the specification $$y_i=(\gamma_i,X)$$. However, the proof then requires it to be possible for Player I to have played the canonical quasistrategy for avoiding this set $$U$$. !Have I attained closure? I want to try jumping to a new definition and hoping that it works. There's a good chance it won't though. As above, let $$A$$ be the set $$\{x\in X:\forall i\ x_i\in\Delta_i\}$$. I now want to define a lift $$\pi:Y\to X$$ as follows. Define a quasistrategy to be //simple// if it is the canonical strategy for avoiding some set $$U$$ of restrictions of the form $$x_i\notin\Delta_i$$. $$Y$$ will consist of sequences of the form $$((\gamma_1,W),(\gamma_2,W),\dots,(\gamma_{n/2},W),(\gamma_{n/2+1},\bullet),\dots,(\gamma_n,\bullet))$$, with the following properties. #$$W$$ is the winning set for some simple quasistrategy. #''either'' $$\bullet$$ is the winning set $$V$$ for some simple quasistrategy for Player II for the shrinking-neighbourhoods game inside $$W$$, and $$V\subset A$$, ''or'' it is a set of coordinate restrictions of the form $$x_i\notin\Delta_i$$. #If $$\bullet$$ is a simple winning set $$V\subset A$$, then the sequence $$x=(\gamma_1,\dots,\gamma_n)$$ belongs to $$V$$. If it is a set of coordinate restrictions, then $$x$$ obeys those restrictions. My question, then, is whether this is a Ramsey lift? That feels like just enough of a new question to be worth putting on a new page, which is I think naturally [[a sister page to this one|Does the suggested simplification work?]]. [[Return to parent page|Can we find an efficient lift by imitating Martin's proof and using an iterative procedure?]].  gowers  That is, for each $$i$$, $$A_i$$ is either a basic set, or a complement of some earlier $$A_j$$, or the intersection or union of two earlier sets in the sequence.  !!Parent page I'm trying to think [[what a $$\Pi_2$$ separating property could possibly be like|What might a proof using a Pi_2 property look like?]]. In the course of thinking about that, I've felt the need to think about NP (=$$\Sigma_1$$) properties. !Introduction I find it very hard to think of NP properties that follow from low circuit complexity and are not in some sense "easy" or "uninteresting" consequences. I want to know whether this is just my lack of imagination or whether there is some genuine phenomenon going on here. But to answer that question requires me to say more precisely what the phenomenon actually is. A major consideration will be that any statement to the effect that NP consequences of low circuit complexity are in some sense "trivial" will need to appeal somehow to the pseudorandomness (or some conjectured stronger form of pseudorandomness) of that property. !Balls in groups It may possibly be relevant that the set $$K$$ I am considering (the set that comes from [[the model of random low-complexity functions|A model of random functions of circuit complexity at most m]]) is closely related to a ball in a group. The group is the alternating group on $$\{0,1\}^n$$ and the generators are the 3-bit scramblers. What we do is take the ball of radius $$m$$ about the identity, which is a set of permutations, and we project every permutation in that ball to the function you obtain if you take just its first coordinate. Because groups are nice, it might be helpful to vary the question slightly so that we can deal directly with this ball, each element of which can be identified with a table of the values taken by the corresponding permutation. The ball itself is defined by an NP property (the property "is a product of generators of length at most $$m$$") and our question is whether there is any other NP property that is "interestingly" implied by this one. Going back to the notion of "boringness", we have already mentioned the following two examples of boring NP sets that contain the ball of radius $$m$$ about the identity. (Or rather, we have mentioned sets of which these two are obvious analogues.) One is balls of larger radius, and the other is unions of the ball of radius $$m$$ with any other NP set. A third example, while I'm at it, can be obtained by taking a ball about some other element of the group, provided the radius is big enough. To be precise, if $$f$$ is of distance at most $$r$$ from the identity, then a ball of radius at least $$m+r$$ about $$f$$ contains the ball of radius $$m$$ about the identity. We can also take intersections of a few sets defined this way. The problem with all these examples -- or rather, the feature that makes them in some sense "trivial" consequences of the property of belonging to the ball of radius $$m$$ -- is that they are all defined in terms of distance in the group (by which I mean in the Cayley graph with the 3-bit scramblers as generators). The hypothesis I am considering is that this is in some sense necessary. That is, //there is no NP property of permutations of $$\{0,1\}^n$$ that correlates with the property "belongs to the ball of radius $$m$$" that is not defined in terms of distance in the Cayley graph// (and is therefore in some sense built out of balls in a simple way). !What I would like to be able to do at this point I would like to consider a wide class of methods of deducing one statement about even permutations of $$\{0,1\}^n$$ from another and translate that into a set of techniques for building subsets of the group $$G=A(\{0,1\}^n)$$. I would like to be able to use this to argue that it is at least //possible// that one cannot build a set that contains a ball unless balls are used very directly in the building process. !What makes this difficult? Any statement like this runs into the problem that it is very hard to say what something like "uses the notion of distance" actually means, because one can take a proof that clearly does use distance and encode it in a way that no longer appears to use distance but in fact does. !How do I hope to get round this difficulty? I'm hoping that by phrasing things in terms of operations that can be performed on sets, I will be able to focus more on what actually matters: the sets themselves rather than the way they are described. !What would count as success? I'm not trying to prove anything. I just want a //reasonable conjecture//, where by "reasonable" I mean something that isn't obviously false. Of course, I'd be even happier if "not obviously false" could be replaced by something stronger like "probably true", since "it is probably a waste of time to look for a proof like this" is a lot stronger than "it might be a waste of time to look for a proof like this". !An annoying example I now realize that looking at sets is not going to help with the encoding problem. Suppose we want to demonstrate in a formal way that the set of permutations at distance at most $$m$$ from the identity is in NP. Informally, the proof is that if you are given a sequence of $$m$$ 3-bit scramblers, then it is easy to check in polynomial time (in $$2^n$$) whether the composition of those 3-bit scramblers agrees with a given permutation. To make that formal, we need to choose a way of encoding the sequence of 3-bit scramblers, and we need to choose an algorithm that checks that the composition equals the given permutation. That gives us a two-variable function $$g(x,y)$$, where $$x$$ is a permutation of $$\{0,1\}^n$$, $$y$$ is an encoding of a composition of $$m$$ 3-bit scramblers, and $$g$$ does the checking. (Part of the checking process will be checking that $$y$$ really is a suitable encoding of a composition of $$m$$ 3-bit scramblers.) We can think of the ball of radius $$m$$ about the identity as the projection of the set of all $$(x,y)$$ such that $$g(x,y)=1$$. Now if we choose a different method of encoding and a correspondingly different checking algorithm, then we will have an entirely different set that //also// projects to the ball of radius $$m$$. So if we are going to claim that the only NP sets that contain the ball are in some sense trivial variants of the same idea, we are going to have to explain in what sense the two sets that project to the ball are not interestingly different. !Is the encoding problem really a problem? It has occurred to me that I am talking about //arbitrary// NP sets that contain the ball of radius $$m$$ about the identity. But shouldn't I be talking about NP sets that I can //prove// contain the ball? I need to think about this, and it feels like a new question. [[ClarifyQuestion|Is there an important difference between "can be deduced from" and "is implied by"?]]
 I've now semi-convinced myself that I should be focusing on NP sets that I can prove contain the ball, rather than on arbitrary NP sets. Or at least, I should reserve that option for myself. Note that this is in contrast with the natural proofs barrier, where one shows that //every// polynomial-time computable property that is implied by low circuit complexity is unsatisfactory, in that it applies to almost all functions. !Some examples of weakenings of the property of having low circuit complexity It occurs to me that one way of capturing the idea of a "trivial" weakening is to look at weakenings that are obtained by modifying just one part of a definition. Let me illustrate what I mean in the case of circuit complexity. The definition of "$$f$$ has circuit complexity at most $$m$$" is *There exists a circuit $$C$$ of size at most $$m$$ such that for every input $$x$$ to $$C$$ the output agrees with $$f(x)$$. One method of trivially weakening this property is to increase $$m$$. But we could also weaken "for every input $$x$$" to something like "for at least two thirds of all inputs" or to "for every input $$x\in X$$" for some suitable subset $$X\subset\{0,1\}^n$$. And we could also weaken "There exists a circuit $$C$$" to the existence of something else that is sufficiently circuit-like for it to be possible to make sense of the idea of the output agreeing with $$f(x)$$. For example, one could allow an "oracle gate" -- that is, in a straight-line computation we could allow $$f_r$$ to be not just some basic Boolean combination of earlier functions but also a function of the form $$\pi\circ(f_{i_1},\dots,f_{i_s})$$ for some specific function $$\pi:\{0,1\}^s\to\{0,1\}$$ of high circuit complexity. To each of these ideas, I have a similar reaction. I feel that if we trivially weaken the property in this way, then it can't really help. For example, if I can prove that it is impossible to compute $$g$$ with a small circuit when "oracle gates" are allowed, isn't it going to be even easier to prove it when "oracle gates" are not allowed? Somehow, what is required seems to be a weakening that takes //work// to prove. For example, perhaps one could allow oracle gates, or some other relaxation of the notion of a circuit, but insist that the resulting generalized circuit is quite a lot smaller. Then we would have to prove that any function that can be computed by a circuit of size $$m$$ can be computed by a generalized circuit of size $$r$$ for some smaller $$r$$. Or perhaps the generalized circuit could not actually be a generalization, but rather a generalization in one way but adding a restriction of another kind. (A well-known example that springs to mind is allowing threshold gates but restricting the depth, though actually proving anything about this seems to be very hard.)  !!Parent page We are trying to decide [[how easy it is to lift a 2-basic set to a 1-basic set|How easy is it to lift a 2-basic set to a 1-basic set?]]. !Introduction In order to think about how to imitate Martin's lift, it will be necessary to say more about what he did than I said [[on this page|A brief primer on Martin's Borel determinacy theorem]]. There I gave a sketch of the proof, but I gave no indication of how the main lemma, which is where all the serious work is involved, is proved. What I am trying to do now corresponds to the main lemma, and since I have not managed to do it from scratch, it is time to think about imitating the main lemma. !The definition of Martin's lift Let $$T$$ be an infinite pruned tree and let $$A\subset[T]$$ be a closed payoff set. (Definitions can be found on the page linked to above.) Martin defines an auxiliary game as follows. Player I begins by playing an initial move $$x_1$$ in $$T$$ together with a quasistrategy $$\sigma$$. <<slider chkQuasistrategyDefinition "Definition of a quasistrategy" "Definition" "Reminder of definition">> This must be done in such a way that $$x_1$$ is one of the possible first moves of $$\sigma$$. Player II responds to Player I's move in one of two ways. Either he plays a second move $$x_2$$ and a quasistrategy $$\tau$$ consistent with $$x_2$$ such that every path consistent with both $$\sigma$$ and $$\tau$$ belongs to $$A$$, or he plays $$x_2$$ and a finite sequence $$u$$ consistent with $$x_1,x_2$$ and $$\sigma$$ that ends at a point after which all possible continuations to infinite paths in $$[T]$$ belong to $$A^c$$. If Player II plays a move of the first kind, then all subsequent moves must be consistent with $$\sigma$$ and $$\tau$$. If he plays a move of the second kind, then the players must play along the finite sequence $$u$$, and once they have reached the end of it they can play how they like. !A quick sketch of the proof that this lift takes winning sets to winning sets Let us consider a strategy $$\sigma'$$ for Player I in the auxiliary game. We need to find a strategy for Player I in the original game that is guaranteed to result in a sequence that could have come from a run of $$\sigma'$$. The strategy $$\sigma'$$ begins with Player I specifying not just a first move in $$T$$ but also a quasistrategy $$\sigma$$. So far, this is not a problem, since Player I can play in $$T$$ what $$\sigma'$$ tells her to play if she has declared the quasistrategy $$\sigma$$. However, it becomes a problem immediately, since she now has to deem Player II to be playing not just a move $$x_2$$ in $$T$$ but also some accompanying information. What information should that be? The answer is a little subtle. Let $$S$$ be the subtree made up of all paths in $$T$$ that are consistent with $$\sigma$$. Suppose that Player I has a winning strategy $$\rho$$ in $$S$$ for reaching a finite sequence all of whose infinite continuations belong to $$A^c$$. Then she plays the strategy $$\rho$$ until such a sequence $$u$$ is reached. At that point, she deems Player II to have played the move $$(x_2,u)$$ for his first move (where $$x_2$$ is the second term of $$u$$). After that point, she plays as $$\sigma'$$ dictates if the first two moves were $$(x_1,\sigma)$$ and $$(x_2,u)$$ and the result is an infinite path that could have come from a run of $$\sigma'$$. If Player I does not have such a winning strategy, then she plays as though Player II has started with the move $$(x_2,\theta)$$, where $$\theta$$ is the //canonical quasistrategy// inside $$S$$ for avoiding finite sequences all of whose continuations (in $$S$$) are in $$A^c$$. This is the quasistrategy "don't move to a point from which the opponent has a winning strategy". Since $$A$$ is closed, if Player II plays consistently with the move $$(x_2,\theta)$$, then the final sequence is guaranteed to end up in $$A$$. But Player II does not have to play consistently with that move. The final twist is that if he doesn't, then Player I has a winning strategy for getting to a finite sequence with all its continuations in $$A^c$$, so she can go back to the first tactic: force such a sequence $$u$$ and deem Player II to have played a move $$(x_2,u)$$. Now let us consider a strategy $$\tau'$$ for Player II in $$T'$$. Thus, in the auxiliary game, Player I chooses a pair $$(x_1,\sigma)$$ and Player II then chooses either a pair $$(x_2,u)$$ or a pair $$(x_2,\tau)$$. We need to define a strategy for Player II in $$T$$, and we do that as follows. When Player I makes a first move $$x_1$$, there is a whole set of possible quasistrategies $$\sigma$$ that are consistent with $$x_1$$. Let $$U$$ be the set of finite sequences $$u$$ such that a pair $$(x_2,u)$$ is the response that $$\tau'$$ makes to at least one such $$\sigma$$. If Player II has a winning strategy for reaching a sequence in $$U$$, then he does so. When he reaches some $$u\in U$$, he chooses a quasistrategy $$\sigma$$ such that $$(x_1,\sigma)$$ would have provoked the response $$(x_2,u)$$ and continues playing as $$\tau'$$ dictates when those are the first two moves. If Player II does not have a winning strategy for reaching a sequence in $$U$$, then he deems Player I to have started with $$(x_1,\theta)$$, where $$\theta$$ is the canonical quasistrategy for avoiding $$U$$, and continues as he would in the auxiliary game when playing $$\tau'$$. If Player I plays consistently with $$\theta$$ then this works. If she ever departs from $$\theta$$, then Player II can force a sequence in $$U$$ and go back to the previous line of attack. !An immediate problem Martin's construction of a lift involves an enormous range of possible first moves for Player I: any quasistrategy is allowed as the initial $$\sigma$$. We are looking for a lift where the amount of "extra information" is tiny by comparison. So one thing we should begin by thinking about is whether it really is necessary in Martin's proof to allow Player I such freedom in her first move in the auxiliary game. !What happens if we restrict the set of quasistrategies that Player I is allowed to use in her first move of the auxiliary game? It doesn't seem to have the slightest effect on the proof that Player I winning sets map to Player I winning sets. Where things get more complicated is in the second part of the proof. The set of quasistrategies that Player I can use needs to be closed under a very strange operation. Let $$\Sigma$$ be the set and suppose that Player I's first move is to choose a pair $$(x_1,\sigma)$$, where $$\sigma$$ is a quasistrategy //from $$\Sigma$$// and $$x_1$$ is consistent with $$\sigma$$. Then if Player I plays $$x_1$$ in the original game, the natural definition of $$U$$ is the set of all finite sequences $$u$$ that can arise in responses that $$\tau'$$ makes to an opening move $$(x_1,\sigma)$$ with $$\sigma\in\Sigma$$. The proof also requires $$\Sigma$$ to contain the canonical quasistrategy for avoiding $$U$$. Since $$\tau'$$ can be any strategy in the auxiliary game, this tells us that for an arbitrary function that takes some quasistrategies in $$\Sigma$$ to finite sequences $$u$$, all of whose continuations belong to $$A^c$$, if Player II does not have a winning strategy for the image of this function, then the canonical quasistrategy for avoiding it is also a quasistrategy in $$\Sigma$$. This appears to tell us at the very least that $$\Sigma$$ does not need to contain more than canonical quasistrategies for avoiding sets of finite paths, all of whose continuations live in $$A^c$$. It also suggests a further approach to the finite problem. Perhaps we can consider an iterative approach to the question of what extra information is needed. That is, we'll start with something simple-minded, and then generate further extra information that corrects the defects in the first attempt while introducing new defects, and so on. Does anything like that work? [[LookForSomethingMoreSpecific|Can we find a Ramsey lift by an iterative procedure?]] !!Parent page We want to [[find a finitary analogue of Martin's theorem|What might a finitary analogue of Martin's theorem look like?]] !!Also relevant We have found that [[there are big problems with the obvious game|Can games with low-complexity payoff sets be lifted to not much larger games with payoff sets that are closed and open?]]. !Introduction In this page we are going to consider the following game. Given a subset $$A\subset\{0,1\}^n$$ the two players take turns specifying bits of a sequence $$x$$. However, unlike with the obvious game, they are allowed to do this in any order. We can think of a position in this game as an element of the set $$\{0,1,*\}^n$$, where an asterisk denotes a bit that has not yet been specified. A strategy for Player I can then be thought of as a function that takes elements of this set with an even number of specified bits (less than $$n$$) and replaces one of the asterisks by either 0 or 1. A strategy for Player II is the same with "odd" replacing "even". !Does this game get round the problems with the obvious game? One of the morals drawn at the end of [[the second page linked to above, about the obvious game|Can games with low-complexity payoff sets be lifted to not much larger games with payoff sets that are closed and open?]] was that if we want to prove a property that is invariant under automorphisms of the tree on which the game is played, then given a set of leaves that we want to regard as "simple", we will need to regard all its images under automorphisms of the tree as "simple" as well. As ever, it is essential that coordinate hyperplanes should be "simple". How do they look in terms of the tree on which the game is played? The leaves of the tree can be labelled with 01-sequences, but if we do that then several leaves will get the same label, since the same final sequence can result in $$n!$$ different ways. If we want a labelling that tells us exactly which leaf we are talking about, then we should label the leaves with a 01-sequence $$x$$ and a permutation $$\gamma$$ of $$\{1,2,\dots,n\}$$. The leaf $$(x,\gamma)$$ then corresponds to the play of the game where the two players specified the bits of $$x$$ in the order $$\gamma(1),\gamma(2),\dots,\gamma(n)$$. Actually, I'm not sure whether that was helpful. I would prefer to think of the vertices of the tree as sequences of bit specifications of the form $$x_{i_1}=\epsilon_1,\ x_{i_2}=\epsilon_2,\ \dots,\ x_{i_k}=\epsilon_k,$$ where $$i_1,\dots,i_k$$ are distinct. Then the coordinate hyperplane we are talking about corresponds to the set of all leaf descendants of sequences of bit specifications such that $$i_k=1$$ and $$\epsilon_k=1$$. Note that there are rather a lot of such sequences, and their sets of descendants are disjoint. So it looks as though this set is rather far from being "open" in the tree. (This relates to the "further thought" in [[the page about the drawbacks with the obvious game|Can games with low-complexity payoff sets be lifted to not much larger games with payoff sets that are closed and open?]].) However, it does have some quite big "chunks" of open set: for example, it contains all lear descendants of the vertex defined by the length-1 bit specification sequence $$x_1=1$$. So perhaps we shouldn't give up straight away, just in case. Can we describe the images of this set under automorphisms of the underlying tree? Let me give it a try. Let $$E_1$$ be the set of leaves we are talking about -- corresponding to the coordinate hyperplane $$x_1=1$$. Let $$T$$ be the tree on which the game is played. Then the root has $$2n$$ children, each of which has $$2(n-1)$$ children, each of which has $$2(n-2)$$ children, and so on. One of the children of the root (corresponding to the specification $$x_1=1$$) has all its leaf descendants in $$E_1$$. Another (corresponding to the specification $$x_1=0$$) has no leaf descendants in $$E_1$$. All remaining children are roots of subtrees of depth $$n-1$$ inside which the set $$E_1$$ sits in isomorphic ways. What's more, they are all isomorphic to the way the set $$E_1$$ sits in the tree if the ground set is $$\{1,2,\dots,n-1\}$$ instead of $$\{1,2,\dots,n\}$$. The following properties characterize $$E_1$$ up to automorphisms of $$T$$. Let us call a vertex //full// if all its leaf descendants belong to $$E_1$$, //empty// if none of them do, and //undecided// if some do and some don't. *The root of $$T$$ is indeterminate. *Every indeterminate vertex of $$T$$ has one full child and one empty child, and all its remaining children are indeterminate. The question is, what sets can we build from sets with these properties using a few Boolean operations? Can we rapidly build everything, or is it quite difficult to build everything? I think the answer is that we can build everything. My rough reason for expecting this is that the proportion of sequences that correspond to $$x_1$$ being specified on the final move of the game is $$1/n$$, which is quite a large proportion, and the subset of those sequences that belongs to $$E_1$$ is very far from open. !!Can we make that more precise? Let $$F$$ be the subset of $$E_1$$ that consists of sequences of specifications where $$x_1$$ is specified last and equals 1. First I claim that we can build $$F$$ out of copies of $$E_1$$. To do this, take an automorphism $$\alpha$$ of $$T$$ that swaps every full vertex that is not a leaf with its (unique) empty sibling. Then $$F=E_1\cap\alpha(E_1)$$. (I haven't checked carefully that this argument is correct, but I think it is.) Next, we can create a very large collection of copies of $$F$$ by taking sequences of specifications where $$x_1$$ is specified last //but does not have to equal 1//. Whatever function we choose of the previous bit specifications will give us a copy of $$F$$ that is the image under some automorphism of $$T$$. This is already far too large a set of functions for it to be reasonable to require all of them to be simple, so I think I won't bother attempting to prove that we can build all functions out of these using a few (by which I probably mean $$Cn$$) Boolean operations. !Conclusion It looks very much as though switching to the permutation-invariant version of the game does not help us to get round the fundamental difficulty that the tree topology is too different from the topology inherited from $$\{0,1\}^n$$. (Here, as everywhere, I am using the word "topology" to mean "structure that will eventually serve as a finitary analogue of a topology.) I haven't quite said this, so let me say it now. A problem we face is that in the infinite case the product topology on the set of all 01-sequences and the topology on the infinite paths of the corresponding binary tree are the same. In the finite case they are not. This is a major //dis//analogy between the two situations, which calls into question the whole idea of modelling a proof of circuit complexity lower bounds on a determinacy argument.  ''Definition.'' A //complexity structure// is a subset $$X$$ of a set $$\Gamma^n$$. Given such a structure, the //basic sets// are all sets of the form $$\{x\in X:x_i\in\Delta\}$$ for some $$1\leq i\leq n$$ and some subset $$\Delta$$ of $$\Gamma$$. ''Definition.'' A //lift// of a complexity structure $$X$$ is a complexity structure $$X'$$ and a map $$\pi:X'\to X$$ such that for every $$x',y'\in X'$$ and every $$1\leq i\leq n$$, if $$x_i'=y_i'$$ then $$\pi(x')_i=\pi(y')_i$$. In other words, the $$i$$th coordinate of $$\pi(x')$$ depends only on the $$i$$th coordinate of $$x'$$. ''Definition.'' A lift $$\pi:X'\to X$$ is //Ramsey// if $$\pi(F)\in\mathcal{F}(X)$$ whenever $$F\in\mathcal{F}(X')$$, where for each complexity structure $$Y$$, $$\mathcal{F}(Y)$$ is the class of subsets of $$Y$$ that we have chosen for our Ramsey property.   (We want sets with low circuit complexity to have efficient Ramsey lifts and arbitrary sets not to have efficient Ramsey lifts. A Ramsey lift is a lift $$\pi:Y\to X$$ such that for every $$F\in\mathcal{F}(Y)$$, $$\pi(F)$$ has a subset in $$\mathcal{F}(X)$$, and for every $$G\in\mathcal{G}(Y)$$, $$\pi(G)$$ has a subset in $$\mathcal{G}(X)$$.)  !!Parent page We are looking into [[whether there is a useful numerical measure of simplicity|Is there a useful numerical measure of simplicity?]]. We are focusing on some conditions that would guarantee that a measure does not exceed the circuit complexity of the set in question. !Introduction We are asking whether a function $$\mu$$ from subsets of $$\{0,1\}^n$$ to $$\mathbb{N}$$ exists with the following properties for every pair of sets $$A$$ and $$B$$. *$$\mu(E_i)=1$$ for every $$i$$. *$$\mu(A\cap B)\leq\max\{\mu(A),\mu(B)\}+1$$ *$$\mu(A\cup B)\leq\max\{\mu(A),\mu(B)\}+1$$ *$$\mu(A^c)=\mu(A)$$ Unfortunately, Pudlak's comments apply to this endeavour as well. Everything one thinks of seems to fall into one of the following two unsatisfactory classes. #It is reasonably simple, but is bounded above by $$n$$ (or just occasionally some small multiple of $$n$$). #It is probably superpolynomially large for some NP function, but it is derived too directly from circuit complexity itself, so proving that fact is basically equivalent to proving that P$$\ne$$NP. !What next? I suggest backtracking as far as the page [[Is there a useful definition of simplicity?]]  The circuit complexity of a subset $$A$$ of a complexity structure $$X$$ is the smallest positive integer $$m$$ such that there exists a sequence $$A_1,A_2,\dots,A_m$$ of subset of $$X$$ with $$A_m=A$$ such that each $$A_i$$ is either a basic set, or the union or intersection of two earlier sets in the sequence. The sequence is called a //straight-line computation// of $$A$$.  !!Parent page We are wondering [[whether we can find a useful analogue of Martin's theorem|What might a finitary analogue of Martin's theorem look like?]]. !!Other relevant pages [[Can games with low-complexity payoff sets be lifted to not much larger games with payoff sets that are closed and open?]] [[Can we find an analogue of Martin's theorem using the obvious invariant game?]] !Introduction The outlook is not very good. Two rather natural candidates for games have been tried, and they have both failed for reasons that seem rather fundamental rather than accidental: a game requires a tree structure and the "topology" on a tree is very different from the "topology" on $$\{0,1\}^n$$. As with the obvious game, there are two questions we could consider asking about a more complicated game. One is whether there might be relatively simple winning strategies for sets of low circuit complexity, and the other is whether there might be proofs of determinacy that involve lifting to sets that are not too large. !Can we find "simple" strategies for complicated games when the payoff set is simple? For the sake of definiteness, let us consider the 3-SAT game. <<slider chkDefineThatGame "What is the 3-SAT game?" "What was that again?" "Reminder of 3-SAT game rules">> This game seems to be pretty complicated even when the payoff set is a coordinate hyperplane. I don't have a strong argument that the answer to this question is no, but I don't think the answer is likely enough to be yes for the question to be worth expending a lot of effort on at this stage. !Can we find economical lifts when the payoff set is simple? Again let us consider the 3-SAT game. It seems unlikely that the symmetry argument can be made to work, since the tree on which this game is played is likely not to have many symmetries. However, the general point that the topology on the tree is wrong appears still to be valid: a typical run of the game, even when the payoff set is a coordinate hyperplane, will not be decided until late on. So there is very little reason to suppose that the answer to this question would be yes either. !Conclusion Probably we can't get anywhere by using a complicated game such as the 3-SAT game.  <<search>><<newTiddler>><<newJournal "DD MMM YYYY" "journal">><<closeAll>>  !!Parent page This page concerns a generalization of the question of [[whether P equals NP|Does P=NP?]]. !Introduction It can be shown (without much difficulty) that every computation that can be performed on a [[Turing machine|http://en.wikipedia.org/wiki/Turing_machine]] in at most $$m$$ steps can be performed with a [[Boolean circuit|http://en.wikipedia.org/wiki/Boolean_circuit]] of size at most $$q(m)$$, where $$q$$ is some fixed polynomial. Thus, the [[circuit complexity|http://en.wikipedia.org/wiki/Circuit_complexity]] of a Boolean function is, to within a polynomial, bounded above by its computational complexity. Turning this round, if we can prove a superpolynomial //lower// bound for the circuit complexity of a Boolean function in NP, then we have a superpolynomial lower bound for the computational complexity of that same function, which shows that P$$\ne$$NP. Thus, the statement "There is an NP function with superpolynomial circuit complexity" is a generalization of the statement "There is an NP function with superpolynomial computational complexity." The virtue of this generalization is mainly its tidying effect on the problem. It is not necessary to learn all the definitions I used in the previous paragraph, since circuit complexity has a very nice equivalent definition, which I shall now give precisely. !Definition of circuit complexity in terms of straight-line computations. For $$i=1,\dots,n$$ let $$E_i$$ be the subset $$\{x:x_i=1\}$$ of $$\{0,1\}^n$$. A //straight-line computation// of a subset $$A\subset\{0,1\}^n$$ is a sequence of sets $$A_1,A_2,\dots,A_m$$ such that $$A_m=A$$ and every $$A_r$$ is of one of the following kinds. *$$A_r=E_i$$ for some $$i$$. *$$A_r=A_s\cap A_r$$ for some $$s,t<r$$. *$$A_r=A_s\cup A_t$$ fpr some $$s,t<r$$. *$$A_r=A_s^c$$ for some $$s<r$$. The circuit complexity of a set $$A$$ is equal to the smallest $$m$$ for which there exists a straight-line computation of $$A$$ with a sequence of length $$m$$. Throughout these pages I shall freely interchange Boolean functions and subsets of $$\{0,1\}^n$$, via the one-to-one correspondence between sets and their characteristic functions. One could reformulate the above definition in terms of functions by using the basic coordinate functions for the $$E_i$$, and replacing the set-theoretic operations intersection, union and complement by the function operations min, max and $$f\mapsto 1-f$$. !A natural strategy for proving that not all NP functions have polynomial circuit complexity We would like to prove that there is a function in NP with superpolynomial circuit complexity. A good first step would be to decide on an NP function that is likely to work. Fortunately, there is a large class of function, namely the [[NP-complete functions|http://en.wikipedia.org/wiki/NP-complete]]. So we can just pick our favourite one of those and hope to prove that it has superpolynomial circuit complexity (and of course adopt a flexible attitude -- it may turn out to be easier to prove this for a different """NP-complete""" function). How might we show that some chosen set $$A$$ has superpolynomial circuit complexity? Given the formulation above, an obvious general strategy is to define a notion of "simplicity". It should have the following properties. *The sets $$E_i$$ are very simple. *The intersection of two sets is not much less simple than the sets themselves. *The union of two sets is not much less simple than the sets themselves. *The complement of a set is not much less simple than the set itself. *$$A$$ is not at all simple. In that way, we might have a chance of an inductive argument. Let us look for a proof along these lines. [[LookForSomethingMoreSpecific|Is there a useful definition of simplicity?]] !!Parent page We are trying and failing to [[find a useful definition of simplicity|Is there a useful definition of simplicity?]]. !Introduction Somehow we always seem to run into the same kind of difficulty: a candidate definition of simplicity/complexity is either too simple to work or requires us to prove a statement that is obviously just as hard as the original problem. Is it possible to understand more precisely what this difficulty is? Yes it is, as was shown in [[a remarkable and famous paper of Razborov and Rudich|http://www.cs.umd.edu/~gasarch/BLOGPAPERS/natural.pdf]], which has had a major impact on research into the P versus NP problem (as well as many other related problems). !Natural proofs We have been considering the following general strategy for proving that some NP function has superpolynomial circuit complexity. First, we define a notion of simplicity. Next, we prove that every function of polynomial circuit complexity is simple. Finally, we prove that some NP function is not simple. What would make a suitable notion of simplicity? We want to avoid something trivial such as "has circuit complexity at most $$n^{\log\log n}$$", since then proving that an NP function is not simple is as hard as the original problem. So it seems as though we are trying to find a simplicity property that is itself "simple" in some sense. (The rough thought here is that if it isn't simple, then we haven't made the problem easier.) Another requirement that seems like a reasonable thing to ask is that simplicity should in some sense be a "rare" property. If 99% of all functions are simple according to our definition, then it is not very reasonable to think of it as a definition of simplicity. Razborov and Rudich proved that we cannot define a notion of simplicity with the following two properties. #Given any Boolean function $$f$$, one can decide in time $$2^{O(n)}$$ whether it is simple. (One is given the truth table of $$f$$, which has size $$n2^n$$, so this is saying that the simplicity property is computable in a time that is polynomial in the size of the truth table.) #At most 99% of all Boolean functions are simple. That isn't quite accurate for two reasons. One is that what they proved was a little stronger: the proportion in 2 can be as high as $$1-2^{-O(n)}$$. More important than this, however, is that they proved the result subject to a complexity assumption: that there exists a suitably strong pseudorandom generator. This is a widely believed hypothesis that is true if (but not only if) factorizing integers is sufficiently hard. !A more informal view of the natural proofs barrier A rough idea that is quite useful when one is trying to think about what a simplicity definition might look like is this: a random function of polynomial circuit complexity is very hard to distinguish from a purely random function. Of course, to make sense of this, one needs to give a definition of a random function of polynomial circuit complexity, but this can be done quite satisfactorily. [[MoreDetails|A model of random functions of circuit complexity at most m]] For the rest of this discussion, I shall therefore feel free to use the phrase "random function of circuit complexity at most $$m$$. It can be shown rigorously that if you take a random function of circuit complexity at most $$m$$ and you would like the images of any $$k$$ elements of $$\{0,1\}^n$$ to be approximately independent and uniformly distributed, then it is sufficient to take (m\) to be at least some polynomial in $$n$$ and $$k$$, and in fact this polynomial can be taken to be pretty small. Stronger pseudorandomness results are harder to come by, but if we are just looking for a plausible argument that a certain way of trying to prove circuit complexity lower bounds is unlikely to work, then rigorous results are not necessary. Here is a general scheme for nonrigorous arguments. #Argue convincingly that a random function of circuit complexity at most $$m$$ is probably pseudorandom in a suitable sense. #Observe that if a candidate simplicity property belongs to the class of properties that cannot tell the difference between pseudorandom functions and genuinely random functions, then the proportion of pseudorandom functions that are simple is roughly the same as the proportion of //all// functions that are simple. #Deduce that in particular, if all random functions of circuit complexity at most $$m$$ are simple, then almost all functions are simple. !What next? At this point, the sensible thing to do seems to be to stop trying to obtain circuit complexity lower bounds and look instead at a much more basic question: what, in the light of the natural proofs barrier, could a proof conceivably look like? [[TryWeakerQuestion|How could one conceivably get round the natural proofs barrier?]]  !!Parent page We are trying to [[assess the prospects for the shrinking-neighbourhoods game|Is the shrinking neighbourhoods game likely to work for our purposes?]]. !Introduction For this page, let us define a //basic $$i$$-set// in a complexity structure $$X$$ to be a subset of the form $$\{x\in X:x_i\in\Delta_i\}$$. (This is not to be confused with an $$i$$-basic set, which is an intersection of at most $$i$$ basic sets.) I would like to know how large an alphabet is needed in general if one wants to lift a basic $$i$$-set to a basic $$j$$-set for some $$j\ne i$$. In fact, I want to know this even in the case $$X=\{0,1\}^n$$. Let's go for the case $$i=m$$ and $$j=n$$, where, as usual, $$m=n/2$$. So we are asking this. If $$X=\{0,1\}^n$$, $$Y\subset\Theta^n$$, and $$\pi:Y\to X$$ is a Ramsey lift such that $$\{x\in X:x_m=1\}$$ is a basic $$n$$-set in $$Y$$, then how big must $$\Theta$$ be? The main thing I'm hoping is that it will not be possible to find an efficient Ramsey lift that simultaneously converts many basic $$i$$-sets into basic $$n$$-sets, since then we will be have lifted arbitrary Boolean combinations of those basic $$i$$-sets to basic $$n$$-sets as well. !The set-up I'm going to think of the lifted game as follows. (I haven't checked whether this is equivalent to the general case, but it is fairly general I think.) We'll let $$Y$$ be a subset of $$X\times U_1\times\dots\times U_n$$, which will have the property that for every $$x\in X$$ there exists $$u\in U_1\times\dots\times U_n$$ such that $$(x,u)\in Y$$. Also, if $$y=(x,u)\in Y$$, then we define the $$i$$th coordinate of $$y$$ to be $$(x_i,u_i)$$. So the idea is that in the auxiliary game the players don't just specify coordinates $$x_i$$, but they also specify $$u_i$$ at the same time, and because $$Y$$ is just a subset of $$X\times U_1\times\dots\times U_n$$, this affects what future specifications are allowed. !The main condition In the case $$X=\{0,1\}^n$$, which is the one I want to look at first, the main requirement is that the value of $$(x_n,u_n)$$ should determine the value of $$x_m$$. Since there are only two possible values of each $$x_i$$, we can, at the cost of doubling the size of each $$U_i$$, insist that the set of possible $$u_i$$ that can be played with $$x_i=0$$ is disjoint from the set of possible $$u_i$$ that can be played with $$x_i=1$$. So let us simplify the discussion by insisting that $$u_n$$ determines $$x_m$$. In terms of the sequences that belong to $$Y$$, this says that we can partition $$U_n$$ into two sets $$U_{n,0}$$ and $$U_{n,1}$$, and for every $$y\in Y$$, if $$y_m=(0,u_m)$$ then $$u_n\in U_{n,0}$$, and if $$y_m=(1,u_m)$$, then $$u_n\in U_{n,1}$$. !Can we somehow find a minimal example? Let's try a proof strategy of the following kind. We'll begin with just the information I've described. That is, $$Y$$ will consist of all sequences $$(x_1,x_2,\dots,x_m,x_{m+1},\dots,x_{n-1},(x_n,x_m))$$. This is the minimal amount of extra information we can add if we want to ensure that $$y_n$$ determines $$x_m$$. This will undoubtedly fail to be a Ramsey lift, so we will try to compensate for its failure by adding further information in a minimal way, continuing this process until eventually we arrive at a Ramsey lift. I don't think this strategy is likely to work, but it's a start. !!Why is the initial lift not Ramsey? Consider the set $$A=\{x:x_m=x_{m+1}=x_n\}$$. In the normal game, $$A^c$$ is a """I-winning""" set, since Player I can wait till Player II first plays one of $$x_{m+1}$$ and $$x_n$$ and can then play $$x_m$$ to be different from that. However, in the modified game, Player II has a winning strategy for $$A$$ (or more precisely for $$\pi^{-1}(A)$$). The strategy is as follows. On the first move, play the specification $$y_n=(0,0)$$ or $$y_n=(1,1)$$. (One of these two is guaranteed to be possible, and if Player I has not already specified $$y_m$$ then they are both possible.) On the second move, specify $$y_{m+1}$$ (which is the same as $$x_{m+1}$$) so as to ensure that $$x_{m+1}=x_n$$. Whenever Player I plays $$x_m$$, she must play it to be equal to $$x_n$$ so she loses. !!What extra information could we add to lessen Player II's advantage in the auxiliary game? I don't have any good answers to this. I can think of extra information that kills off Player II's advantage completely: for example, we could let Player I decide whether $$x_m=x_n$$. But that just seems to create equally serious problems in the other direction -- by which I mean simple payoff sets that are not """I-winning""" in the original game but are in the auxiliary game. !Can we get some traction on the question by restricting the form of the extra information? Let me pick a restriction at random. I'll take $$Y$$ to be a subset of the set of all sequences of the form $$((x_1,u),\dots,(x_m,u),x_{m+1},\dots,x_{n-1},(x_n,v))$$ with $$u\in U$$ and $$v\in V$$. Let us write $$X_{u,v}$$ for the set of all $$x\in X$$ such that $$((x_1,u),\dots,(x_m,u),x_{m+1},\dots,x_{n-1},(x_n,v))\in Y$$. The idea is that Player I provides a piece of extra information $$u$$ on her first move, and Player II provides extra information $$v$$ when he specifies $$x_n$$, and all moves must be compatible with this extra information -- meaning that it must at all stages be possible for the final sequence to end up in $$X_{u,v}$$. Actually, I think it will be simpler to change $$Y$$ to something more symmetrical in the first instance. So let's instead go for a subset of the set of all sequences of the form $$((x_1,u),\dots,(x_m,u),(x_{m+1},v),\dots,(x_n,v))$$ with $$u\in U$$ and $$v\in V$$. So now both players have to declare their extra information on their first moves. (This may be disastrous -- I don't actually know whether there exists a Ramsey lift with this property, other than completely trivial examples where the extra information doesn't actually say anything.) !!Attempt at proof I am going to "suspend" the choice of the extra information. That is, I am going to attempt to prove that the lift is Ramsey without saying what the extra information is, and if I find that I need certain properties, I'll note down those properties. Then at the end of that process I'll see whether the properties I need can be satisfied. Let $$\sigma$$ be a winning strategy for a set $$W\subset Y$$ for Player I. Let us try to convert that into a winning strategy for Player I in $$X$$ for the set $$\pi(W)$$. Suppose that Player I's first move according to $$\sigma$$ is $$y_i=(\gamma_i,u)$$. Then Player I can play the specification $$x_i=\gamma_i$$ in $$X$$. Now suppose that Player II responds with $$x_j=\gamma_j$$. This immediately places a significant condition on the extra information: the declaration of $$u$$ must not rule out Player II playing the move $$y_j=(\gamma_j,v)$$ for some $$v$$. I need to rephrase things. For each $$(i,\gamma,u)$$ let $$\mathcal{X}_{i,\gamma,u}$$ be the set of all sets $$X_{i,\gamma,u,v}$$, where $$X_{i,\gamma,u,v}=\{x\in X_{u,v}:x_i=\gamma\}$$. We can think of Player I's extra information as a choice of $$\mathcal{X}_{i,\gamma,u}$$, from which Player II gets to choose some $$X_{i,\gamma,u,v}$$ inside which the rest of the game will take place. (He also gets to choose a specification $$x_j=\gamma'$$ which must be consistent with $$x_i=\gamma$$ inside $$X_{i,\gamma,u,v}$$.) Basically what happens is that Player I offers Player II a choice of possible restrictions of the game, and Player II gets to choose which restriction he wants to go for. How can this not make some sets winning sets that were not winning sets before? To answer this question I want to simplify the set-up slightly. Let's consider a different situation where Player I chooses a set $$\mathcal{X}_u$$ of sets $$X_{u,v}$$, Player II chooses one of the sets $$X_{u,v}$$, and thereafter the game takes place inside the set $$X_{u,v}$$. Then we need that for every """I-winning""" set $$W$$ there will be some $$u$$ such that for every $$v$$ the set $$W\cap X_{u,v}$$ is """I-winning""" in $$X_{u,v}$$. We also need that for every """II-winning""" set $$W$$ and every $$u$$ there exists $$v$$ such that $$W\cap X_{u,v}$$ is """II-winning""" in $$X_{u,v}$$. A trivial way of getting these conditions to hold is for Player I's extra information to consist of a winning set and for Player II's to be a point in that winning set. More accurately, the sets $$X_{u,v}$$ are all the singletons consisting of elements in a winning set that is indicated by $$u$$. Then if $$W$$ is a """I-winning""" set, Player I simply chooses $$W$$, Player II chooses a point $$x$$ in $$W$$, and a trivial game is played where the two players specify the coordinates of $$x$$. If $$W$$ is a """II-winning""" set, then it intersects all """I-winning""" sets, so whichever winning set $$W'$$ Player I declares, Player II chooses a point $$x\in W\cap W'$$ and declares that. What I would like to do is find a much cruder way of doing this. The key property that I'm asking for is that for fixed $$n$$ the amount of extra information should be bounded as the alphabet size of $$X$$ increases. If that is the case, then the number of sets $$X_{u,v}$$ is bounded, and that gives us a nice concrete question. Suppose that the number of sets $$X_{u,v}$$ we are allowed to use is bounded, but the alphabet size of $$X$$ tends to infinity. Can we prove that there is some winning set that does not lift to a winning set for the same player? This is a weaker question than the one we started with, so it needs a new page. [[TryWeakerQuestion|If we add a bounded amount of information in two additional first moves, must the lift fail to be Ramsey?]] !An important observation Let us say that the extra initial two moves //simplify// $$A$$ if after they have been played we know whether the final sequence will belong to $$A$$. Equivalently, they simplify $$A$$ if every set $$X_{u,v}$$ is a subset either of $$A$$ or of $$X\setminus A$$. It is easy to put a lower bound on the amount of extra information needed to simplify all basic sets simultaneously. Observe first that that implies that every $$X_{u,v}$$ is a singleton, since otherwise we could find $$A$$ that contains one element of $$X_{u,v}$$ and not another, so if the first two moves were $$u$$ and then $$v$$, we would not know whether the eventual sequence would belong to $$A$$. So in this special situation we can think of the game as follows. Player I gets to choose a set $$V$$ from some collection $$\mathcal{V}$$ of subsets of $$X$$, and Player II gets to choose a point $$v\in V$$. Thereafter, all specifications must be of the form $$x_i=v_i$$, so that the eventual sequence will be $$v$$. If $$W$$ is a """I-winning""" set, then $$\mathcal{V}$$ must contain some subset of $$W$$, since otherwise after Player I's first move, Player II can always choose a point not in $$W$$. Conversely, if $$W$$ is not a """I-winning""" set, then it cannot belong to $$\mathcal{V}$$, since otherwise it would become a """I-winning""" set in the auxiliary game. It follows that $$\mathcal{V}$$ must contain every minimal """I-winning""" set, and therefore be doubly exponential in size. The reason this is important is that it strongly suggests that a similar result holds for lifts. That is, I think it should be possible to prove in a similar way that if all basic subsets of $$\{0,1\}^n$$ can be simultaneously lifted to basic $$n$$-sets, then the alphabet size has to be doubly exponential. And if that is the case, then it tells us that in general it is not easy to lift basic $$i$$-sets to basic $$j$$-sets. (I won't give a precise statement, but the point I'm making is that if it were easy to do, then one could compose a number of such lifts and obtain a contradiction to the fact that the bound for simultaneously converting all basic $$i$$-sets to basic $$n$$-sets has to be doubly exponential (assuming that that does indeed go through as expected). ''Open Task: modify the simple observation above to show that a lift that simultaneously converts all basic sets into basic $$n$$-sets must have an alphabet that is at least as big as the number of minimal """I-winning""" sets.'' [encoded data, 7048 characters]

posted:  | author:  | space:  | tagged with:  | tagging:

  !Parent page We want to know [[whether a lift can be Ramsey if we add a bounded amount of information in two addtional first moves|If we add a bounded amount of information in two additional first moves, must the lift fail to be Ramsey?]]. !Introduction Our complexity structure can be thought of as the complete bipartite graph on $$r+r$$ vertices. A minimal """I-winning""" set in the original game is the set of all edges incident with some vertex in the first vertex set, while a minimal """II-winning""" set is a set of $$r$$ edges, one joined to each vertex in the first vertex set. Now let $$G_{ij}, i,j=1,\dots,k$$ be a collection of proper subgraphs of $$K_{r,r}$$. The main point here is that $$k$$ should be bounded. The fact that there are exactly $$k$$ graphs $$G_{ij}$$ for each $$i$$ is not important at all -- indeed, I do not insist that the $$G_{ij}$$ are distinct. The auxiliary game is this. Player I chooses $$i$$, Player II chooses $$j$$, and the game takes place inside $$G_{ij}$$. We want to know, under suitable conditions, how small $$k$$ can be. !Attempt at proof that k must be unbounded Let $$W$$ be a winning set for Player I, consisting of all edges $$xy, y=1,2,\dots,r$$. What condition on the $$G_{ij}$$ guarantees that $$W$$ is a """I-winning""" set in the new game? ''Claim.'' We need some $$i$$ such that for every $$j$$, $$G_{ij}$$ contains an edge incident with $$x$$. ''Proof of claim.'' If the condition holds and Player I chooses that $$i$$, then whatever $$j$$ Player II chooses, Player I can choose $$x$$, and all neighbours of $$x$$ in $$G_{ij}$$ belong to $$W$$. Conversely, if the condition does not hold, then for every $$i$$ Player II can choose $$G_{ij}$$ that contains no edge incident with $$x$$, and thus no edge in $$W$$. Now let $$W$$ be a set of the form $$\{xf(x):x\in [r]\}$$. Under what conditions will $$W$$ be a """II-winning""" set in the auxiliary game? We need that for every $$i$$ there exists $$j$$ such that for every $$x$$ that is not isolated in $$G_{ij}$$, the edge $$xf(x)$$ belongs to $$G_{ij}$$. That's a complicated-looking condition, but perhaps it becomes simpler when we look at what has to hold for it to be true for //every// function $$f:[r]\to[r]$$. Also, we don't have to worry too much about the "for every $$i$$" -- we can look at a single $$i$$, work out the condition, and then insist that it holds for all $$i$$. So we have a set of graphs $$G_1,\dots,G_k$$, and for every $$f:[r]\to[r]$$ there exists $$j$$ such that for every $$x$$ that is not isolated in $$G_j$$ the edge $$xf(x)$$ belongs to $$G_j$$. (I haven't said this, but the graphs $$G_j$$ must each contain at least one edge.) Given a particular graph $$G_j$$, which functions $$f$$ does it deal with? It deals with all functions such that $$xf(x)$$ is an edge of $$G_j$$ for every $$x$$ that is not isolated in $$G_j$$. !Example 1 It seems to be easy to produce an example that works. We don't even need Player I to have any choice about $$i$$, and we can take two graphs $$G$$ and $$H$$, where $$G$$ consists of all edges apart from $$(1,1)$$ and $$H$$ consists of all edges apart from $$(1,2)$$. Player I's first move consists in doing nothing, then Player II gets to choose one of $$G$$ and $$H$$, inside which the rest of the game will take place. If $$W$$ is a """I-winning""" set then there exists $$x$$ such that every $$xy$$ belongs to $$W$$. This will still be the case if we restrict to $$G$$ or $$H$$. And if $$W$$ is """II-winning""", then the only way it can fail to be """II-winning""" inside $$G$$ is if the only point $$(1,x)$$ in $$W$$ is the point $$(1,1)$$. But in that case $$W$$ is """II-winning""" inside $$H$$. !Modification of question when n=2 There is something slightly too "trivial" about the example just given, in that the extra information merely rules out one edge. What if we insist that the graphs $$G_{ij}$$ have density at most 1/2? I think the picture may be very different. First of all, we need that for each $$x$$ there exists $$i$$ such that all the $$G_{ij}$$ contain at least one edge incident with $$x$$. !Example 2 How about letting $$V_1,V_2$$ be a partition of $$[r]$$ into two equal parts and letting $$G_{11}$$ be the complete bipartite graph from $$V_1$$ to $$[r]$$ and $$G_{21}$$ be the complete bipartite graph from $$V_2$$ to $$[r]$$? If $$W$$ is a """I-winning""" set, then it contains all neighbours of some $$x$$. If we choose $$i$$ such that $$V_i$$ contains that $$x$$, then the rest of the game takes place in $$G_{i1}$$, which still contains all neighbours of $$x$$. So $$W$$ remains """I-winning""". Now let $$W$$ be a """II-winning""" set. If we restrict the game to $$G_{i1}$$, then all that does is restrict the first move that Player I can make, which doesn't stop $$W$$ from being """II-winning""". So this is another rather trivial-seeming example. !Further modification of question Example 2 still feels too trivial. What happens if every graph $$G_{ij}$$ is required to have maximum degree $$r/2$$? Is it still possible to get away with a bounded number of graphs? No it isn't. Here's the proof. Let $$G$$ be a subgraph of $$K_{r,r}$$ with $$t$$ non-isolated vertices in the first copy of $$[r]$$ and maximum degree $$r/2$$. For a minimal """II-winning""" set defined by a function $$f:[r]\to[r]$$ to remain """II-winning""" when restricted to $$G$$, you need that for each non-isolated vertex $$x$$ in the first copy of $$r$$, $$f(x)$$ is a neighbour of $$x$$ in $$G$$. Therefore, if $$f$$ is chosen randomly, the probability that the corresponding minimal """II-winning""" set remains """II-winning""" in $$G$$ is at most $$2^{-t}$$. For any given $$i$$, what does this tell us about the graphs $$G_{i1},\dots,G_{ik}$$? It tells us that if every $$G_{ij}$$ has at least $$t$$ non-isolated vertices in the first copy of $$[r]$$, then $$k\geq 2^t$$. Now recall the condition for """I-winning""" sets to be preserved. We need that for each $$x$$ in the first copy of $$[r]$$ there exists $$i$$ such that $$x$$ is non-isolated in every $$G_{ij}$$. By the pigeonhole principle there is some $$i$$ that works for at least $$r/k$$ vertices $$x$$, which means that for that $$i$$ every $$G_{ij}$$ contains at least $$r/k$$ vertices in the first copy of $$[r]$$. From that it follows that $$k\geq 2^{r/k}$$, so $$k$$ must be at least $$cr/\log r$$. !What next? This feels like a small piece of genuine progress: it is the first even slightly interesting lower bound I've obtained for anything at all with this project, and the method looks as though it could conceivably generalize to more complicated situations. What I'm mainly referring to here when I say "the method" is the idea that a "genuine restriction" of the game either preserves only a small number of """I-winning""" sets or preserves only a small number of """II-winning""" sets, so you need to have lots of them. [[Back to parent page|If we add a bounded amount of information in two additional first moves, must the lift fail to be Ramsey?]]  !!Parent page We are wondering [[whether there is a useful formal complexity measure|Is there a useful formal complexity measure?]]. While the answer seems to be no if one is trying to prove lower bounds for circuit complexity, things might be very different if we are satisfied with lower bounds for formula complexity. !Introduction Our hope was that this would be an easier problem. The bad news is that it doesn't seem to be. (Perhaps it is, but it is difficult to compare the difficulty of two problems when one is completely stuck on both.) The best known lower bounds for formula complexity are slightly better than the best known lower bounds for circuit complexity (round about $$n^3$$ instead of round about $$n$$), but there appear to be deep difficulties common to both problems. For now, let me summarize the difficulty with formula complexity by quoting a slide from [[a talk given by Pavel Pudlak|http://www.dim.uchile.cl/~redes/workshop/slides/pudlak.pdf]]. The slide is entitled, "Why are we not able to prove exponential lower bound?" and the answer he gives is this. #Simple measures give only small bounds. #Measures that could prove exponential lower bounds are difficult to estimate. Here are a couple of examples that illustrate this. Suppose we define the complexity of a Boolean function to be the number of variables on which that function actually depends. It is easy to check that this is a formal complexity measure. However, it can never be greater than $$n$$ so it is useless for our purposes. (The best known lower bounds are given by complexity measures that are similar in spirit to this one, but cleverer.) And now suppose we go to the opposite extreme and define the complexity to be its formula complexity. That almost certainly can in principle give us an exponential lower bound, but proving it is precisely the problem we are trying to solve. Difficulties with this general flavour pervade the whole of computational complexity theory. !What next? I suggest backtracking as far as the question [[Is there a useful definition of simplicity?]]  The //shrinking-neighbourhoods game// is defined in a complexity structure $$X\subset\Gamma^n$$ as follows. The two players take turns to specify the coordinates of a point in $$X$$, the only rules being (i) that at each stage it must be possible to extend the current specification so that it really does yield a point in $$X$$, and (ii) Player I must always specify one of the first $$n/2$$ coordinates and Player II must always specify one of the last $$n/2$$ coordinates. A subset $$W\subset X$$ is //"""I-winning"""// (respectively //"""II-winning"""//) if Player I (respectively Player II) has a winning strategy in this game for reaching a point in $$W$$.  * [[GettingStarted]] * [[SiteInfo]] * [[SiteOrganization|Organizing an open maths notebook]] * [[PvsNP Sitemap|A sitemap for the P versus NP notebook]]  A //basic set// in a complexity structure $$X\subset\Gamma^n$$ <<slider chkDefineComplexityStructure "What is a complexity structure again?" "What's that?" "Reminder of definition">> is a subset of the form $$\{x\in X:x_i=\gamma_i\}$$. A $$k$$-//basic open set// is an intersection of $$k$$ basic sets. A $$k$$-//open// set is a union of $$k$$-basic open sets. A $$k$$-//closed// set is a complement of a $$k$$-open set. In particular, since the complement of a basic set is a basic set, a 1-closed set is any intersection of basic sets and a 1-open set is any union of basic sets. For the definition of a lift, look at the definition of complexity structures. A lift $$\pi:Y\to X$$ is //Ramsey// if for every """I-winning""" (respectively """II-winning""") subset $$W$$ of $$Y$$, the set $$\pi(W)$$ is a """I-winning""" (respectively """II-winning""") subset of $$X$$. <<slider chkDefineWinningSets "What is a winning set?" "What are those?" "Reminder of definition">>  !!Parent page We want to know [[whether the property of preserving half-dimensionality places a significant restriction on lifts|Is it easy to Ramsey-lift an arbitrary set to a simple set?]]. !Introduction The trivial lift is defined as follows. Let $$A\subset\{0,1\}^n$$. Let $$\Gamma=\{00,01,10,11\}$$. Given a sequence $$x=(x_1,\dots,x_n)\in\Gamma^n$$, let $$\theta(x)\in\{0,1\}^n$$ be the sequence that replaces each $$x_i$$ by its first bit. Let $$X\subset\Gamma^n$$ consist of all sequences $$x\in\Gamma^n$$ such that either $$\theta(x)\in A$$ and the second bit of $$x_1$$ is 1 or $$\theta(x)\notin A$$ and the second bit of $$x$$ is 0. Let $$\pi$$ be the restriction of $$\theta$$ to $$X$$. Then $$\pi^{-1}(A)=\{x\in X:x_1\in\{01,11\}\}$$, so it is a basic set. The question we are asking in this page is the following: if $$W$$ is a half-dimensional subset of $$X$$, then must $$\pi(W)$$ be half-dimensional in $$\{0,1\}^n$$? We are very much hoping that the answer will be no, since otherwise the entire approach will probably be in serious trouble. In our favour is that we haven't yet completely decided what a half-dimensional set is, though we have narrowed down the options considerably. !!!Remark. What I am calling the Ramsey property is the property that $$\pi$$ takes half-dimensional sets to half-dimensional sets. I started calling it a Ramsey property because half-dimensional sets are the sets to which a Ramsey theorem ought to apply. But it's not a very good name. Maybe "Ramsey-preserving property" would be better. That's actually not too bad, since if $$\pi$$ has the property, then if a lift has the Ramsey property it implies that the original structure had it too. !A candidate for a half-dimensional set whose image is not half dimensional Let $$A$$ be a random subset of $$\{0,1\}^n$$ and let $$B$$ be a random subset of $$A$$ of relative density 9/10. If the notion of half-dimensionality can be defined in such a way that any two half-dimensional sets intersect, then it is not possible for both $$B$$ and $$B^c$$ to be half-dimensional. Since $$B$$ is a random set of density less than 1/2, and half-dimensionality is a monotone property, one would expect the probability that $$B$$ is half-dimensional to be extremely small. Now let $$W=\pi^{-1}(B)$$. I would like to claim that $$W$$ is half dimensional. However, no sooner have I written that down than I see that it is a rather unlikely claim, since $$W^c$$ looks much more likely to be half dimensional, containing as it does both $$\pi^{-1}(A^c)$$ and a big chunk of $$\pi^{-1}(A)$$. !A second candidate for a half-dimensional set whose image is not half dimensional It occurs to me that it is better to look for a subset of $$\{0,1\}^n$$ that is not half dimensional but that has a preimage in $$X$$ that //is// half dimensional. That's because by monotonicity I might as well take my hoped-for half-dimensional set to be the entire preimage of its hoped-for non-half-dimensional image. I am hoping that affine subspaces of $$n/2$$ dimensions (or maybe just ones that are obtained by restricting $$n/2$$ coordinates) will be half-dimensional, despite being very small. If I do indeed have that property, then let $$V$$ be a linear subspace of $$\{0,1\}^n$$ of dimension $$n/2$$ and let $$A$$ be a random subset. Let $$B=(A\cap V)\cup(A^c\cap(V+e_1))$$, where $$e_1$$ is the vector $$(1,0,0,\dots,0)$$. What I'm hoping here is that because $$V$$ is "only just" half dimensional and because the two parts of $$B$$ do not line up properly, this set is not half dimensional. I'm also hoping that $$\pi^{-1}(B)$$ has a slight advantage over $$B$$ because the first coordinate of every point in $$\pi^{-1}(B)$$ is confined to the set $$\{01,10$$\). (That is because for each point $$x\in B$$, if $$x\in A\cap V$$, then the first coordinate of $$\pi^{-1}(x)$$ is $$01$$, and if $$x\in A^c\cap(V+e_1)$$, then the first coordinate of $$\pi^{-1}(x)$$ is $$10$$. Going back to $$B$$, note that it is a random subset of the subspace $$V+\{0,e_1\}$$. So I would basically be wanting to show for one part of this that if you take a random 90% of a subspace of dimension $$n/2+1$$ (of course, this could be adjusted), then you don't get a half-dimensional set. I'm a little disturbed however, because I would have hoped that it would be //obvious// that this trivial lift does not preserve half-dimensional sets. !What happens in the tree case? To get a proper handle on this, let me see whether there is an analogue of this lift in the case of games on trees. That will surely fail to work, and with luck its failure will be instructive. I think the right analogue is as follows. Let $$A$$ be a subset of the set $$[T]$$ of all leaves in an $$n$$-level tree $$T$$ (or equivalently of all paths. We now create a new tree $$T'$$ as follows. We take the subtree $$T_1$$ of $$T$$ that consists of all paths that end in $$A$$ and the subtree $$T_2$$ that consists of all paths that end in $$A$$, and we identify their roots (but nothing else). Thus, $$T'$$ has two subtrees that intersect only at the root, one that corresponds to $$A$$ and the other that corresponds to $$A^c$$. The map $$\pi:T'\to T$$ is the obvious one -- its restriction to each part of $$T'$$ is the inclusion map corresponding to that part. Now I would like to find a strategic subtree of $$T'$$ whose image does not contain a strategic subtree of $$T$$. That is indeed trivial. Let us consider two cases. If Player I does not have a winning strategy for $$A$$, then consider any strategic subtree $$S$$ for Player I in $$T'$$ such that the unique successor $$v$$ of the root is in the half of $$T'$$ that corresponds to $$A$$. All descendants of $$v$$ belong to $$A$$, so $$\pi(S)$$ is a tree with all its leaves in $$A$$. Since Player I does not have a winning strategy for $$A$$, $$\pi(S)$$ does not contain a strategic subtree. If Player I does have a winning strategy for $$A$$, then Player II does not have a winning strategy for $$A^c$$. In that case ... ah, I'm in trouble here, because Player II can't force the game to stay in $$A^c$$ in $$T'$$. Ah, but maybe that doesn't matter too much. It shows that the trivial lift that just pulls apart $$A$$ and $$A^c$$ doesn't work if Player I does not have a winning strategy for $$A$$. So we get that it doesn't in general work. Similarly, it doesn't work if Player I does not have a winning strategy for $$A^c$$. But I don't find that very comforting. For example, if I let $$A$$ consist of nine tenths of all sequences (thought of as leaves of a binary tree) that begin with 0 and one tenth of all sequences that begin with 1, chosen randomly, then with high probability Player I has a winning strategy for both $$A$$ and $$A^c$$. To win $$A$$, she should make sure that $$x_1=0$$, after which the game takes place in a set where $$A$$ is a random subset of density 9/10, and to win $$A^c$$ she should make sure that $$x_1=1$$ to obtain the same situation for $$A^c$$. And that allows a vast class of sets, vast enough that we can I think make all others out of them using just a few Boolean operations. If Player II doesn't have a winning strategy for either $$A$$ or $$A^c$$, then how can we find a strategic subtree $$S$$ for Player II of $$T'$$ such that $$\pi(S)$$ is non-winning for Player II? Maybe we don't have to try all that hard. First, let's describe what strategic subtrees for Player II (from now on I'll call them """II-subtrees""") in $$T'$$ look like. Since the two subtrees $$T_1$$ and $$T_2$$ meet only at the root and their union is $$T$$, the first thing to say is that $$S$$ splits into two: $$S\cap T_1$$ is a """II-subtree""" of $$T_1$$ and $$S\cap T_2$$ is a """II-subtree""" of $$T_2$$. So our task is reduced to describing """II-subtrees""" of $$T_1$$ and $$T_2$$. We can think of $$T_1$$ as playing a game on the binary tree subject to the additional rule that you are not allowed to move to a vertex that does not have a descendant in $$A$$. For most of the game, this has little effect, since almost all low-level vertices have at least one descendant in $$A$$. But towards the end, it becomes a more serious restriction. $$T_2$$ is playing a game where you are not allowed to move to a vertex that does not have a descendant in $$A^c$$. A strategic subtree of $$T_1$$ can be constructed as follows. Take an arbitrary strategic subtree $$S$$ of $$T$$, intersect its leaves with $$A$$, and then follow all paths from the resulting points back to the root. An easier way of looking at it is this. Let's call a subset of $$[T]$$ a //"""II-set"""// if it is the set of leaves of a """II-subtree""" of $$T$$. Then to obtain a """II-subset""" of $$[T_1]$$ you just intersect a """II-subset""" of $$[T]$$ with $$A$$. Similarly, to obtain a """II-subset""" of $$[T_2]$$ you intersect a """II-subset""" of $$[T]$$ with $$A^c$$. Therefore, if we want to obtain a set that is the image under $$\pi$$ of a """II-subtree""" of $$T'$$, we can take any two """II-subsets""" $$S_1$$ and $$S_2$$ of $$[T]$$ and take the set $$(S_1\cap A)\cup(S_2\cap A^c)$$. It seems to me that there isn't the slightest reason to expect that this set will contain a """II-subset""". ''//Open Task: turn that into a rigorous argument.//'' !Conclusion I have not reached this conclusion at all rigorously, but I am now fairly convinced that it is not annoyingly easy to lift an arbitrary set to a very simple set using a map $$\pi$$ that preserves half-dimensionality. My rough reason is that we ought to be able to obtain, as the image of a half-dimensional set, a set that is the intersection of $$A$$ with one half-dimensional set and $$A^c$$ with another. And that doesn't sound as though it has much reason to be half-dimensional. ''//Open Task: make this more rigorous too.//'' [[Return to parent page|Is it easy to Ramsey-lift an arbitrary set to a simple set?]]  !!Parent page We are trying to [[see whether there is any mileage in the idea of a half-dimensional subset|What is the right definition of a "half-dimensional set"?]]. !Introduction The precise question is this. We are given an arbitrary subset $$A\subset\{0,1\}^n$$. Can we find a lift $$\pi:X\to\{0,1\}^n$$ for some complexity structure $$X\subset\Gamma^n$$ such that $$\Gamma$$ is not much bigger than $$\{0,1\}$$, $$\pi^{-1}(A)$$ is built very simply from basic sets using elementary Boolean operations (or perhaps is even basic itself), and $$\pi$$ takes half-dimensional sets to half-dimensional sets? (Here "half-dimensional" means "at least half-dimensional".) Or rather, that is the precise question if we have a precise definition of "half-dimensional". One of the purposes of this page is to see whether there is likely to be //any// reasonable such definition that will make the answer to the above question no (which is very much what we hope it will be). !Do we already have a trivial Ramsey lift? A potential disaster that it would be good to rule out is that the lift [[defined here|How large an alphabet do we need to make a set basic?]] //already// has the Ramsey property. That gives us a more specific question to think about. [[TryToFindCounterexample|Does the trivial lift have the Ramsey property?]]
 The answer appears to be no. So the next question is this. !Is it likely that a slightly less trivial lift would do the job? I don't have a very good argument for this, so here's a weak argument: the trivial lift appears to fail badly enough that it is hard to believe that a lift that works could be only slighlty less trivial. ''//Open Task: investigate this question further.//'' [[Return to parent page|What is the right definition of a "half-dimensional set"?]] <svg xmlns="http://www.w3.org/2000/svg" xmlns:xl="http://www.w3.org/1999/xlink" version="1.1" viewBox="301 225 48 52" width="30" height="30"> <g stroke="none" stroke-opacity="1" stroke-dasharray="none" fill="none" fill-opacity="1"> <g> <path d="M 333.00003 234 L 306 258.75003 L 301.5 270 L 312.75 265.50003 L 339.75 240.74998 Z M 337.5 229.50002 L 335.24988 231.75008 L 341.99997 238.50003 L 344.24997 236.24995 Z M 342 225.00003 L 339.74988 227.25009 L 346.5 234.00005 L 348.75 231.75003 Z M 301.5 273.9719 C 301.5 273.9719 309.59888 277.99927 317.70013 273.97183 C 325.80066 269.94437 341.99997 276.65686 341.99997 276.65686 L 341.99997 273.97195 C 341.99997 273.97195 325.80014 267.2594 317.70013 271.28687 C 309.6 275.31451 301.5 271.28683 301.5 271.28683 Z" fill="#101010" class="glyph"/> </g> </g> </svg> /*** https://raw.github.com/tiddlyweb/chrjs/master/main.js ***/ //{{{ // TiddlyWeb adaptor // v0.14.3 /*jslint vars: true, unparam: true, nomen: true, white: true */ /*global jQuery */ var tiddlyweb = (function($) {

"use strict";

var tw = {
routes: {
// host is the TiddlyWeb instance's URI (including server_prefix)
// placeholders "_type" & "name" refer to the respective bag/recipe
root     : "{host}/",
bags     : "{host}/bags",
bag      : "{host}/bags/{name}",
recipes  : "{host}/recipes",
recipe   : "{host}/recipes/{name}",
tiddlers : "{host}/{_type}s/{name}/tiddlers",
tiddler  : "{host}/{_type}s/{name}/tiddlers/{title}",
revisions: "{host}/{_type}s/{name}/tiddlers/{title}/revisions",
revision : "{host}/{_type}s/{name}/tiddlers/{title}/revisions/{revision}",
search   : "{host}/search?q={query}"
}
};

var convertTimestamp, supplant;

// host (optional) is the URI of the originating TiddlyWeb instance
tw.Resource = function(type, host) {
if(arguments.length) { // initialization
this._type = type;
if(host !== false) {
this.host = host !== undefined ? host.replace(/\/$/, "") : null; } } };$.extend(tw.Resource.prototype, {
// retrieves resource from server
// callback is passed resource, status, XHR (cf. jQuery.ajax success)
// errback is passed XHR, error, exception, resource (cf. jQuery.ajax error)
// filters is an optional filter string (e.g. "select=tag:foo;limit=5")
get: function(callback, errback, filters) {
var uri = this.route();
if(filters) {
var separator = uri.indexOf("?") === -1 ? "?" : ";";
uri += separator + filters;
}
var self = this;
return $.ajax({ url: uri, type: "GET", dataType: "json", success: function(data, status, xhr) { var resource = self.parse(data); resource.etag = xhr.getResponseHeader("Etag"); callback(resource, status, xhr); }, error: function(xhr, error, exc) { errback(xhr, error, exc, self); } }); }, // sends resource to server // callback is passed data, status, XHR (cf. jQuery.ajax success) // errback is passed XHR, error, exception, resource (cf. jQuery.ajax error) put: function(callback, errback) { var self = this; var options = { url: this.route(), type: "PUT", contentType: "application/json", data: JSON.stringify(this.baseData()), success: function(data, status, xhr) { callback(self, status, xhr); }, error: function(xhr, error, exc) { errback(xhr, error, exc, self); } }; if(this.ajaxSetup) { this.ajaxSetup(options); } return$.ajax(options);
},
// deletes resource on server
// callback is passed data, status, XHR (cf. jQuery.ajax success)
// errback is passed XHR, error, exception, resource (cf. jQuery.ajax error)
"delete": function(callback, errback) {
var self = this;
var options = {
url: this.route(),
type: "DELETE",
success: function(data, status, xhr) {
callback(self, status, xhr);
},
error: function(xhr, error, exc) {
errback(xhr, error, exc, self);
}
};
if(this.ajaxSetup) {
this.ajaxSetup(options);
}
return $.ajax(options); }, // returns an object carrying only the essential information of the resource baseData: function() { var data = {}, self = this;$.each(this.data, function(i, item) {
var value = self[item];
if(value !== undefined) {
data[item] = value;
}
});
return data;
},
// returns corresponding instance from a raw object (if applicable)
parse: function(data) {
return data;
},
// list of accepted keys in serialization
data: [],
// returns resource's URI
route: function() {
return supplant(tw.routes[this._type], this);
}
});

var Container = function(type, name, host) {
if(arguments.length) { // initialization
tw.Resource.apply(this, [type, host]);
this.name = name;
this.desc = "";
this.policy = new tw.Policy({});
}
};
Container.prototype = new tw.Resource();
$.extend(Container.prototype, { tiddlers: function() { return new tw.TiddlerCollection(this); }, parse: function(data) { var type = tw._capitalize(this._type), container = new tw[type](this.name, this.host); data.policy = new tw.Policy(data.policy); return$.extend(container, data);
},
data: ["desc", "policy"]
});

// attribs is an object whose members are merged into the instance (e.g. query)
tw.Collection = function(type, host, attribs) {
if(arguments.length) { // initialization
tw.Resource.apply(this, [type, host]);
$.extend(this, attribs); } }; tw.Collection.prototype = new tw.Resource(); tw.TiddlerCollection = function(container, tiddler) { if(arguments.length) { // initialization tw.Collection.apply(this, [tiddler ? "revisions" : "tiddlers"]); this.container = container || null; this.tiddler = tiddler || null; } }; tw.TiddlerCollection.prototype = new tw.Collection();$.extend(tw.TiddlerCollection.prototype, {
parse: function(data) {
var container = this.container;
return $.map(data, function(item, i) { var tiddler = new tw.Tiddler(item.title, container), bag = item.bag; tiddler = tw.Tiddler.prototype.parse.apply(tiddler, [item]); if(!tiddler.bag && bag) { // XXX: bag always present!? tiddler.bag = new tw.Bag(bag, container.host); } if(!tiddler.recipe && item.recipe) { tiddler.recipe = new tw.Recipe(item.recipe, container.host); } delete item.recipe; return$.extend(tiddler, item);
});
},
route: function() {
var params = this.container;
if(this.tiddler) {
var container = this.tiddler.bag || this.tiddler.recipe;
params = {
_type: container._type,
host: container.host,
name: container.name,
title: this.tiddler.title
};
}
return supplant(tw.routes[this._type], params);
}
});

tw.Search = function(query, host) {
tw.Collection.apply(this, ["search", host]);
this.query = query;
};
tw.Search.prototype = new tw.Collection();
$.extend(tw.Search.prototype, { parse: function(data) { this.container = { // XXX: hacky _type: "bag", host: this.host }; var tiddlers = tw.TiddlerCollection.prototype.parse.apply(this, arguments); delete this.container; return tiddlers; } }); // title is the name of the tiddler // container (optional) is an instance of either Bag or Recipe // optionally accepts a single object representing tiddler attributes tw.Tiddler = function(title, container) { tw.Resource.apply(this, ["tiddler", false]); this.title = title; this.bag = container && container._type === "bag" ? container : null; this.recipe = container && container._type === "recipe" ? container : null; var self = this;$.each(this.data, function(i, item) {
self[item] = undefined; // exposes list of standard attributes for inspectability
});
if(title && title.title) { // title is an object of tiddler attributes
$.extend(this, title); } }; tw.Tiddler.prototype = new tw.Resource();$.extend(tw.Tiddler.prototype, {
revisions: function() {
return new tw.TiddlerCollection(this.bag || this.recipe, this);
},
route: function() {
var container = this.bag || this.recipe;
var params = $.extend({}, this, { host: container ? container.host : null, _type: this.bag ? "bag" : (this.recipe ? "recipe" : null), name: container ? container.name : null }); return supplant(tw.routes[this._type], params); }, parse: function(data) { var tiddler = new tw.Tiddler(this.title), container = this.bag || this.recipe; if(data.bag) { tiddler.bag = new tw.Bag(data.bag, container.host); delete data.bag; } delete data.recipe; tiddler.created = data.created ? convertTimestamp(data.created) : new Date(); delete data.created; tiddler.modified = data.modified ? convertTimestamp(data.modified) : new Date(); delete data.modified; if(this.recipe) { tiddler.recipe = this.recipe; } return$.extend(tiddler, data);
},
data: ["created", "creator", "modifier", "modified", "tags", "type", "text",
"fields"],
ajaxSetup: function(options) {
var self = this;
if(this.etag && (options.type === "PUT" || options.type === "DELETE")) {
options.beforeSend = function(xhr) {
};
}
if(options.type === "PUT") {
var callback = options.success;
options.success = function(data, status, xhr) {
if(loc && etag) {
self.etag = etag;
if(!self.bag) {
var bag = loc.split("/bags/").pop().split("/")[0];
self.bag = new tw.Bag(bag, self.recipe.host);
}
callback(self, status, xhr);
} else { // IE
self.get(callback, options.error);
}
};
}
}
});

tw.Revision = function(id, tiddler) {
var container = tiddler.bag || tiddler.recipe;
tw.Tiddler.apply(this, [tiddler.title, container]);
this._type = "revision";
this.revision = id;
};
tw.Revision.prototype = new tw.Tiddler();
$.extend(tw.Revision.prototype, { revisions: false, data: false, put: false, "delete": false }); tw.Bag = function(name, host) { Container.apply(this, ["bag", name, host]); }; tw.Bag.prototype = new Container(); tw.Recipe = function(name, host) { Container.apply(this, ["recipe", name, host]); this.recipe = []; }; tw.Recipe.prototype = new Container();$.extend(tw.Recipe.prototype, {
data: ["recipe"].concat(Container.prototype.data)
});

tw.Policy = function(constraints) { // TODO: validation?
var self = this;
$.each(this.constraints, function(i, item) { self[item] = constraints[item]; }); }; tw.Policy.prototype.constraints = ["read", "write", "create", "delete", "manage", "accept", "owner"]; /* * utilities */ tw._capitalize = function(str) { return str.charAt(0).toUpperCase() + str.slice(1); }; // convert YYYYMMDDhhmmss timestamp to Date instance convertTimestamp = function(t) { if (t.match(/^\d{12,17}$/)) {
return new Date(Date.UTC(
parseInt(t.substr(0, 4), 10),
parseInt(t.substr(4, 2), 10) - 1,
parseInt(t.substr(6, 2), 10),
parseInt(t.substr(8, 2), 10),
parseInt(t.substr(10, 2), 10),
parseInt(t.substr(12, 2) || "0", 10),
parseInt(t.substr(14, 3) || "0", 10)
));
} else {
return new Date(Date.parse(t));
}
};

supplant = function(str, obj) {
return str.replace(/{([^{}]*)}/g, function (a, b) {
var r = obj[b];
r = typeof r === "string" || typeof r === "number" ? r : a;
return $.inArray(b, ["host", "query"]) !== -1 ? r : encodeURIComponent(r); // XXX: special-casing }); }; return tw; }(jQuery)); //}}} ''PAGE IN PROGRESS'' !!Parent page We are trying to establish [[whether non-trivial Ramsey lifts require large alphabets|Must all non-trivial Ramsey lifts use large alphabets?]]. !Introduction Let me try to describe what a trivial lift is in a way that makes it easy to think about. Suppose we have a map $$\pi:Y\to X$$, where $$X\subset\Gamma^n$$ and $$Y\subset\Theta^n$$. I call it trivial if it has the following property, which is a lot stronger than saying that $$\pi$$ is a surjection. Suppose one wanted to prove that $$\pi$$ was a surjection. One way to do it would be to take an arbitrary $$x\in X$$, take its coordinates in some arbitrary order $$\gamma_{\sigma(1)},\dots,\gamma_{\sigma(n)}$$ and then choose preimages $$\theta_{\sigma_1},\dots,\theta_{\sigma(n)}$$ of the $$\gamma_i$$. In general, this will not necessarily work very well: one might find that after one has chosen $$\theta_{\sigma_1},\dots,\theta_{\sigma(k)}$$ there is no preimage $$\theta_{\sigma(k+1)}$$ of $$\gamma_{\sigma(k+1)}$$ for which some $$y\in Y$$ satisfies $$y_{\sigma(i)}=\theta_{\sigma(i)}$$ for $$i=1,2,\dots,k+1$$. In other words, one might have to backtrack. Roughly speaking, a trivial lift is a surjection for which backtracking is never necessary. More formally, the definition is this. For every set $$K\subset\{1,2,\dots,n\}$$ that is not the whole of $$\{1,2,\dots,n\}$$, every set of specifications $$x_i=\gamma_i$$ ($$i\in K$$), every set of specifications $$y_i=\theta_i$$ ($$i\in K$$) such that $$\pi(\theta_i)=\gamma_i$$ for each $$i\in K$$ and every specification $$x_j=\gamma_j$$ for some $$j\notin K$$ that is consistent with the specifications of the $$x_i$$ for $$i\in K$$, there is a specification $$y_j=\theta_j$$ consistent with the specifications of the $$y_i$$ for $$i\in K$$ such that $$\pi(\theta_j)=\gamma_j$$. I wish I could think of a more concise way of putting that, but I hope the idea is clear. The question I now want to ask is whether, if $$\pi:Y\to X$$ is a trivial lift, the circuit complexity of $$\pi^{-1}(A)$$ can ever be smaller than the circuit complexity of $$A$$. <<slider chkDefinitionCircuitComplexity "The circuit complexity of a subset of a complexity structure" "How is this defined?" "Reminder of definition">> I am expecting the answer to be no. !A first proof attempt I'm just going to dive in and try to prove that the answer is indeed no. The obvious thing to do is to take a straight-line computation of $$\pi^{-1}(A)$$ and try to convert it into a straight-line computation of $$A$$ of the same length. However, it does not seem to be very easy to do that, because $$\pi$$ does not have to preserve intersections. If there were some argument that said that we might as well confine our straight-line computation in $$Y$$ to inverse images of subsets of $$X$$, then it would be fine, but I do not see an obvious argument for that. Indeed, there can't be //too// obvious an argument for that, since the result is false in general (there are Ramsey lifts that turn all sets into basic sets). We must use the triviality condition somehow, and it is not clear how. !What now? Given that the first proof attempt has not even got off the ground, what should we do next? Here are some possible splitting questions. 1. Suppose that the lift is the most trivial type of all, where $$X\subset\Gamma^n$$, $$\phi:\Theta\to\Gamma$$ is a surjection, $$\pi(\theta_1,\dots,\theta_n)$$ is defined to be $$(\phi(\theta_1),\dots,\phi(\theta_n))$$, and $$Y$$ is defined to be $$\pi^{-1}(X)$$. Can we //then// show that it is impossible for $$\pi^{-1}(A)$$ to have smaller circuit complexity than $$A$$? [[TryWeakerQuestion|Can super-trivial lifts reduce circuit complexity?]] 2. In the general case, can we show something more modest, such as that if $$\pi:Y\to X$$ is a trivial lift and $$A$$ is a basic subset of $$X$$ obtained by restricting the second coordinate, then $$\pi^{-1}(A)$$ cannot be a basic subset of $$Y$$ obtained by restricting the first coordinate? (Of course, I assume that $$A$$ is not also a basic subset of $$X$$ obtained by restricting the first coordinate.) I ask a closely related question further down this page, and the proof answers this question as well. [[The answer is no|Can a trivial lift lift a non-basic set to a basic set?]].
 The answer to the first question is no, and the proof is quite easy, so perhaps it is worth thinking about whether the proof can be generalized to arbitrary trivial lifts. !Does a trivial lift contain a copy of the original structure? Let me try to prove that it does. For simplicity, I'll look at the case where $$X=\{0,1\}^n$$. So the question I'm asking is this. Let $$Y\subset\Theta^n$$ and let $$\pi:Y\to\{0,1\}^n$$ be a trivial lift. Can we find $$\theta_{i,0},\theta_{i,1}\in\Theta$$ for $$i=1,2,\dots,n$$ such that for every $$\epsilon\in\{0,1\}^n$$ we have $$(\theta_{1,\epsilon_1},\dots,\theta_{n,\epsilon_n})\in Y$$ and $$\pi(\theta_{1,\epsilon_1},\dots,\theta_{n,\epsilon_n})=\epsilon$$? Let us try to pick such $$\theta_{i,0}$$ and $$\theta_{i,1}$$ greedily. By the triviality condition applied with $$K=\emptyset$$ and to the specifications $$x_1=0$$ and $$x_1=1$$, we can find $$\theta_{1,0}$$ and $$\theta_{1,1}$$ such that if $$y_1=\theta_{1,\eta}$$, then $$\pi(y)_1=\eta$$. Now I want to pick $$\theta_{2,0}$$ and $$\theta_{2,1}$$. But here I start to have a problem, which is that the $$\theta_{2,0}$$ I choose if I apply the triviality condition with $$K=\{1\}$$ and the specifications $$x_1=0$$, $$y_1=\theta_{1,0}$$ and $$x_2=0$$ is not necessarily the same as the $$\theta_{2,0}$$ I choose if I apply it with $$K=\{1\}$$ and the specifications $$x_1=1$$, $$y_1=\theta_{1,1}$$ and $$x_2=0$$. !!The answer appears to be no in general Here is a sketch of an argument that a trivial lift need not contain a copy of the original structure. Suppose that we take $$\Theta=\Theta_0\cup\Theta_1$$, where $$\Theta_0$$ and $$\Theta_1$$ are disjoint sets of size $$M$$, where $$M$$ will be chosen later. Let $$\pi:\Theta^n\to\{0,1\}^n$$ be the map that collapses $$\Theta_0$$ to $$\{0\}$$ and $$\Theta_1$$ to $$\{1\}$$. Let $$Y$$ be a random subset of $$\Theta^n$$, with each element chosen independently with probability 1/2. I claim that if $$M$$ is something like $$4^n$$ then this gives us a trivial lift. That's because the property we need is that for any $$K$$, any specification of the coordinates $$y_i$$ with $$i\in K$$ and any $$j\notin K$$ we can find some $$\theta_j\in\Theta_0$$ and some other $$\theta_j'\in\Theta_1$$ such that the specifications $$y_j=\theta_j$$ and $$y_j=\theta_j'$$ are both consistent with the specifications in $$K$$ and with belonging to $$Y$$. The expected number of possibilities for $$\theta_j$$ will be $$2^{-|K|}M$$ and the probability of there being many fewer than that is tiny if $$M$$ is comfortably bigger than $$2^n$$. I now claim that for $$Y$$ to contain a copy of $$X$$ we would need $$M$$ to be far bigger than that. For each choice of $$\theta_{i,0}\in\Theta_0$$, $$\theta_{i,1}\in\Theta_1$$, $$i=1,\dots,n$$, the probability that the set $$\prod_{i=1}^n\{\theta_{i,0},\theta_{i,1}\}$$ is a subset of $$Y$$ is $$2^{-2^n}$$. The number of such sets is $$M^{2n}$$. So to stand a reasonable chance of one of them being a subset of $$Y$$ we need $$M$$ to be around $$2^{2^n/2n}$$ -- that is, doubly exponential. !What now? That last example appears to show that the proof that super-trivial lifts cannot simplify sets is too simple to tell us why a similar result might be true for trivial lifts. However, it also gives us a new splitting question: if we define a lift by taking a super-trivial lift and passing to a random subset (with appropriate probabilities and sizes of alphabet), can the circuit complexity of a set go down? [[TryWeakerQuestion|Can random subsets of super-trivial lifts reduce circuit complexity?]]
 It looks as though the answer to this question is also no, but unfortunately the natural proof (not in Razborov and Rudich's sense) seems to be a simple counting argument, which does not look likely to generalize to an arbitrary trivial lift unless we can rephrase it somehow. What would constitute such a rephrasing? It would be to show that all that was actually needed was a pseudorandomness property that trivial lifts have. Rather than try to jump ahead and guess what such a property might be, let us see whether we can use the triviality condition to deduce any of the facts that held in the case of random subsets of super-trivial lifts. !Does the triviality condition allow us to lift straight-line computations up to super-trivial lifts? It won't be immediately clear what the above question means. Here is what I have in mind. Suppose we have a complexity structure $$X$$ and a trivial lift $$\psi:Z\to X$$. I would like to embed $$Z$$ into a super-trivial lift $$\pi:Y\to X$$. That is, I would like to find a super-trivial lift $$\pi:Y\to X$$ such that $$Z\subset Y$$ and the restriction of $$\pi$$ to $$Z$$ is $$\psi$$. Let $$Z\subset\Theta_1\times\dots\times\Theta_n$$ and let $$\psi_1,\dots,\psi_n$$ be such that $$\psi(z)=(\psi_1(z_1),\dots,\psi_n(z_n))$$ for each $$z\in Z$$. We can now define $$Y$$ to be $$\Theta_1\times\dots\times\Theta_n$$, with $$\pi(y)$$ given by the same formula. That is, it's $$(\psi_1(y_1),\dots,\psi_n(y_n))$$. The question I am asking is this. Given a straight-line computation $$C_1,\dots,C_m$$ of a set $$C$$ in $$Z$$, is there a unique straight-line computation $$B_1,\dots,B_m$$ of a set $$B$$ in $$Y$$ such that $$C_i=Z\cap B_i$$ for every $$i$$, and such that $$B_i$$ is basic if $$C_i$$ is, and $$B_i$$ is the intersection/union of two earlier $$B_j$$ if $$C_i$$ is the intersection/union of the corresponding earlier $$C_j$$? Let's start by asking whether if $$C_i$$ is a basic set in $$Z$$, then there is a unique basic set $$B_i$$ in $$Y$$ such that $$B_i\cap Z=C_i$$. If $$C_i=\{z\in Z:z_r\in\Delta_r\}$$ for some subset $$\Delta_r\subset\Theta_r$$, then we can take $$B_i$$ to be $$\{y\in Y:y_r\in\Delta_r\}$$. The question is whether we can take $$B_i$$ to be any other basic set. Suppose then that $$B_i'=\{y\in Y:y_r\in\Delta_r'\}$$ with $$\Delta_r'\ne\Delta_r$$. Let $$C_i'=\{z\in Z:z_r\in\Delta_r'\}$$. Then our question is whether $$C_i'$$ can equal $$C_i$$. Without loss of generality there exists $$\theta\in\Delta_i'\setminus\Delta_i$$. I realize now that in order to make the result work I need a further condition: that every element of every $$\Theta_r$$ is actually used in some $$z\in Z$$. Without that, what I'm trying to prove is obviously false. With that extra condition, I can find $$z\in Z$$ such that $$z_r=\theta$$. Then $$z\in C_i'\setminus C_i$$ and we have a contradiction. So with the extra condition, we get that there is a unique choice for the basic sets $$B_i$$. And the remaining $$B_i$$ are also determined by the Boolean operations that give the remaining $$C_i$$. So we can make sense of the straight-line computation in $$Y$$ that corresponds to a given straight-line computation in $$Z$$. I don't see how to get from this to a proof that trivial lifts can't simplify sets, so let's simplify the problem and ask the following: can a trivial lift lift a non-basic set to a basic set? This is a variant of one of the questions proposed earlier. [[TryWeakerQuestion|Can a trivial lift lift a non-basic set to a basic set?]].
 The answer to that question is, as hoped, no. Better still, the triviality condition was used in the proof (as it had to be, since the result is false for general maps). !Should we try to show directly that a trivial map preserves circuit complexity? Suppose that $$\pi:Y\to X$$ is a trivial map and that $$B_1,\dots,B_m$$ is a straight-line computation of a set $$B\subset Y$$. Suppose also that $$B=\pi^{-1}(A)$$. Is it reasonable to hope that $$\pi(B_1),\dots,\pi(B_m)$$ is a straight-line computation of $$A$$? A preliminary observation is that the triviality condition guarantees that $$\pi$$ is a surjection, from which it follows that $$\pi(\pi^{-1}(A))=A$$ for every set $$A\subset X$$. So we do at least have that $$\pi(B)=A$$ here. However, if $$B_i=B_r\cap B_s$$, then we do not necessarily have $$\pi(B_i)=\pi(B_r)\cap\pi(B_s)$$, so this simple-minded approach will not work unless we adjust it somehow. Could we, for example, modify the sets $$B_i$$ so that their images remain the same, but now intersections go to intersections? I do not immediately see how to do this, so I think it would be a good idea to consider the simplest special case I have not yet considered, namely the case where $$B$$ is an intersection of two basic sets. [[TryWeakerQuestion|If a trivial lift of a set is the intersection of two basic sets, must the original set be the intersection of two basic sets?]]
 That appeared to work, and show that if $$\pi:Y\to X$$ is a trivial lift and $$\pi^{-1}(A)$$ is the intersection of two basic sets in $$Y$$, then $$A$$ is the intersection of two basic sets in $$X$$. Unfortunately, the proof began with a reasonably simple characterization of sets that are //not// intersections of two basic sets. It is not clear how one would characterize sets that cannot be created from basic sets using a given circuit, which is what would seem to be the natural generalization. ''Open Task: push on and solve this question.''  !!Parent page We want to know [[how worrying it is that Borel sets can be lifted to basic sets in the infinite case|How discouraging is it that Martin can lift any finite collection of Borel sets simultaneously to very simple sets?]]. !Introduction At the end of [[this page|Is there an easy Ramsey lifting that makes all sets simple?]] a Ramsey lift is presented, with an alphabet of doubly exponential size, that makes all sets basic. However, the proof that it works uses the result that finite games are determined. Is there some way of ruling such proofs out? The way it might conceivably be possible is if we can ask a bit more of our lifts. For example, instead of just asking for them to take winning sets to winning sets, we might insist that there is a nice way of mapping winning strategies for those winning sets to winning strategies for their images. If we rely on finite determinacy, it is not obvious that this can be done, since we are basically using an existence proof for the strategy. The question is whether we can make this informal argument precise in some way. Another place where we have used finite determinacy is in the following equivalence: a map $$\pi:Y\to X$$ is Ramsey if and only if for every winning set $$A\subset X$$ we have that $$\pi^{-1}(A)$$ is a winning set in $$Y$$ for the same player. So another question we might ask is whether there is some strengthening of the notion of a lift for which this equivalence does not hold. !If we use a determinacy-based lift, what can't we do? The determinacy-based lift I have in mind is defined as follows. Let $$X\subset\Gamma^n$$ be a complexity structure. We define $$Y$$ to consist of all sequences $$(y_1,\dots,y_n)$$ with the following properties. #For exactly one $$i\leq m$$, $$y_i$$ is a pair $$(\gamma_i,W)$$, where $$W$$ is a """I-winning""" set and $$x_i=\gamma_i$$ is the first move of a winning strategy for getting into $$W$$. #For all other $$i\leq m$$, $$y_i$$ is an element of $$\Gamma$$. #There exists $$w\in W$$ such that every $$y_j$$ with $$j>m$$ takes the form $$(\gamma_j,w)$$, where $$\gamma_j\in\Gamma$$. #$$w=(\gamma_1,\dots,\gamma_n)$$. Let us look at part of the proof that the image of a """II-winning""" set is """II-winning""". Let $$V$$ be a """II-winning""" subset of $$Y$$ and let $$\sigma$$ be a winning strategy for getting into $$V$$. Then for every pair $$(\gamma_i,W)$$ such that $$W$$ is a """I-winning""" subset of $$X$$ and $$x_i=\gamma_i$$ is the first move of a winning strategy for getting into $$W$$ the strategy $$\sigma$$ gives us a pair $$(\gamma_j,w)$$, and in particular $$w$$, such that $$w\in W\cap\pi(V)$$. Therefore, $$\pi(V)$$ intersects every """I-winning""" subset of $$X$$, from which it follows by determinacy that it is """II-winning""". What does that tell us about a winning strategy for $$\pi(V)$$? As far as I can see, it tells us more or less nothing, apart from the fact that it exists. What it doesn't seem to give us is a way of converting a winning strategy for $$V$$ into a winning strategy for $$\pi(V)$$. To play the $$\pi(V)$$ game, it doesn't seem to help to pretend that we are playing an auxiliary game in $$Y$$ where the object is to get into $$V$$. This contrasts with Martin's proof, where it //does// help to play an auxiliary game on the side. What one is allowed to do is interesting, and possibly points the way to a strengthened definition of a lift. Suppose you are Player II. Then in the auxiliary game, Player I starts with a move in the real game combined with some extra information". So your immediate problem is to think of a good way of deciding what extra information you are going to pretend that Player I has played, so that you can use your winning strategy in the auxiliary game to depend on it. Unfortunately, whatever you decide, Player I may go on and do something in the real game that is inconsistent with this extra information. However, that is all right as long as you can change the extra information you are pretending she has played in such a way that the new extra information is consistent with the moves played so far and with your winning strategy in the auxiliary game. In other words, you are allowed to backtrack in the auxiliary game, but not in the real game, and the backtracking in the auxiliary game must be consistent with what has happened so far in the real game. !Martin lifts closed sets to open sets, so can't we therefore lift arbitrary sets to open sets with not too awful bounds? Martin's lifts make use of the """Gale-Stewart""" theorem, that open (and hence closed) sets are determined. But in the finite set-up, all sets are open, so it is not clear how to distinguish between finite determinacy and an analogue of the """Gale-Stewart""" theorem. Let's see whether we can get a doubly exponential upper bound by imitating Martin's construction, and thereby get an explicit way of converting strategies in $$Y$$ into strategies in $$X$$ (where by "explicit way" I am referring to the property discussed at the end of the previous section). So $$A\subset X$$ is the set I am trying to simplify by lifting. I propose to do so as follows. I'll let $$Y$$ consist of all sequences $$(y_1,\dots,y_n)$$ with the following properties. #For exactly one $$i\leq m$$, $$y_i$$ is a pair $$(\gamma_i,W)$$, where $$W$$ is a """I-winning""" set in $$X$$ and the specification $$x_i=\gamma_i$$ is the first move of a winning strategy for Player I for $$W$$. #For every other $$i\leq m$$, $$y_i\in\Gamma$$. #For every $$i>m$$, $$y_i$$ takes the form $$(\gamma_i,\bullet)$$, where $$\bullet$$ is either a subset $$V$$ of $$W\cap A$$ that is """II-winning""" inside $$W$$ or a set of specifications consistent with $$W$$ such that every sequence in $$X$$ that is consistent with those specifications belongs to $$X\setminus A$$. #If $$\bullet$$ is a set $$V$$, then $$(\gamma_1,\dots,\gamma_n)\in V$$. #If $$\bullet$$ is a set of specifications, then $$(\gamma_1,\dots,\gamma_n)$$ obeys those specifications. What I have done there is write down what feels like the best translation, given the dictionary I have, of Martin's lift from the infinite-games set-up to the complexity-structures set-up. Since it is something of a guess, it probably won't turn out to be a Ramsey lift, but let me check. !Attempted proof that the above structure is a Ramsey lift Let $$Z$$ be a """I-winning""" subset of $$Y$$ and let $$\sigma$$ be a """I-winning""" strategy for getting into $$Z$$. We would like to devise a """I-winning""" strategy in $$X$$ for arriving in $$\pi(Z)$$. To do this, we shall try to explain how to play the game in $$X$$ while playing an imagined game in $$Y$$ on the side. Let $$\tau$$ be the strategy we are defining in $$X$$. If the first move of $$\sigma$$ is $$y_i=(\gamma_i,W)$$, then the first move of $$\tau$$ is $$x_i=\gamma_i$$. If the first move of $$\sigma$$ is $$y_i=\gamma_i$$, then again the first move of $$\tau$$ is $$x_i=\gamma_i$$. At this point, Player II will make a move (in $$X$$) of the form $$x_j=\gamma_j$$, and we have to deem him to be playing a move in $$Y$$ of the form $$y_j=(\gamma_j,\bullet)$$. The difficulty is that we do not know what $$\bullet$$ is, but on our side is that we can go back and change our minds later if we need to. Let us consider the case where the first move of $$\sigma$$ is of the form $$y_i=(\gamma_i,W)$$. Suppose that after the move $$x_i=\gamma_i$$ Player I has a winning strategy for arriving in $$W\setminus A$$. Then she can play this strategy and at the end of the game deem Player II to have chosen $$\bullet$$ to be the complete specification of the sequence that results. If Player I does not have a winning strategy for arriving in $$W\setminus A$$ after the first move, then Player II has a winning strategy for arriving in $$A$$, from which it follows that if Player I plays a winning strategy for $$W$$, then Player II can ensure that the resulting sequence will belong to $$W\cap A$$. So if Player II plays the move $$x_j=\gamma_j$$ in $$X$$, then let Player I deem Player II to have played $$y_j=(\gamma_j,W\cap A)$$ in $$Y$$ and let her continue to play the projection of whatever $$\sigma$$ dictates, given the choices of $$W$$ and $$\bullet$$. If the final sequence belongs to $$A$$, then it is consistent with these choices. If it belongs to $$A^c$$, then we can go back and pretend that Player II chose $$\bullet$$ to be a complete specification of that sequence. That feels worryingly trivial. And it looks as though it will continue to be worryingly trivial when I come to discuss Player II's strategies. So I'll abandon it for the moment, because I have a more pressing need. !What was the supposed "strong" lift property? What precisely does it mean to say that a lift gives us a way of converting strategies to strategies? I think it is this. Let $$\pi:Y\to X$$ be a lift and let $$\sigma$$ be a strategy for Player I in $$Y$$. (I choose Player I just for the sake of illustration.) Let $$W$$ be the set of all possible final sequences that can result if Player I plays $$\sigma$$. The Ramsey property would demand that we should be able to find a strategy $$\tau$$ in $$X$$ for Player I for ensuring that the final sequence belongs to $$\pi(W)$$. Now let us think how we might define such a $$\tau$$. The natural thing to do to start with is to take the initial move $$y_i=\theta_i$$ demanded by $$\sigma$$ and to play the move $$x_i=\pi_i(\sigma)$$ (where $$\pi_i$$ is what $$\pi$$ does to the $$i$$th coordinate). If Player II responds with $$x_j=\gamma_j$$, then what are we to do next? One possibility is to choose a move $$y_j=\theta_j$$ such that $$\pi_j(\theta_j)=\gamma_j$$ and pretend that Player II has played it in $$Y$$. Then we can take the move $$y_h=\gamma_h$$ that $$\sigma$$ demands after the initial moves $$y_i=\theta_i$$ and $$y_j=\theta_j$$ and project it to the move $$x_h=\pi_h(\gamma_h)$$ in $$X$$. Now suppose that Player II plays $$x_k=\gamma_k$$. What we would like to do at this point is choose a specification $$y_k=\theta_k$$ such that $$\pi_k(\theta_k)=\gamma_k)$$. However, while such a specification exists (at least if $$\pi_k$$ is a surjection), it is not necessary for there to be a sequence $$y\in Y$$ that satisfies a specification of this kind together with the three specifications made so far. What if there doesn't? Then we have the option of backtracking in $$Y$$. What we need to find is four consistent specifications $$y_i=\theta_i'$$, $$y_j=\theta_j'$$, $$y_h=\theta_h'$$ and $$y_k=\theta_k'$$ such that Player I's moves are those dictated by $$\sigma$$ (so in fact $$\theta_i'$$ must be $$\theta_i$$) and the projections are still the moves made so far in $$X$$. Then Player I can continue with the policy of doing what $$\sigma$$ dictates and projecting. What we obtain here if we can keep this process going is a strategy $$\tau$$ with the following property: for every run of the game in $$X$$ with Player I playing $$\tau$$ there is a run of the game in $$Y$$ with Player I playing $$\sigma$$ that projects to it. This is essentially Martin's definition of a lift of games, and it seems to be a stronger property than the property that winning sets go to winning sets. !Yes but is it really a stronger property? In particular, does the determinacy-based lift have this stronger property? Let's see what happens to """II-winning""" strategies, which is the ones that I thought were going to be troublesome. If Player I begins with the move $$x_i=\gamma_i$$, then Player II has to decide what move she has played in $$Y$$ in order to respond to it as $$\sigma$$ (a strategy for Player II in $$Y$$) dictates. Let's suppose he picks some """I-winning""" set $$W$$ for which the move $$x_i=\gamma_i$$ is the first move of a winning strategy and deems Player I to have played $$y_i=(\gamma_i,W)$$. In $$Y$$ he will respond to this with a move of the form $$y_j=(\gamma_j,w)$$, where $$w$$ is a sequence in $$W$$ such that $$w_i=\gamma_i$$ and $$w_j=\gamma_j$$. However, there is nothing to force Player I to play in $$X$$ consistently with this choice of $$w$$. The question we now face is whether Player II will always be able to adjust to what Player I does. Suppose, then, that Player I plays a move $$x_h=\gamma_h$$ and that $$w_h\ne\gamma_h$$. In order to continue with the auxiliary-game approach, Player II now needs to find a """I-winning""" set $$W'$$ and some $$w'\in W'$$ with the following properties. #$$x_i=\gamma_i$$ is the first move of a winning strategy for Player I for getting into $$W'$$. #$$w_i'=\gamma_i, w_j'=\gamma_j,$$ and $$w_h'=\gamma_h$$. #If in $$Y$$ the first move is $$y_i=(\gamma_i,W')$$, then $$\sigma$$ dictates that the next move is $$y_j=(\gamma_j,w')$$. I can't see any reason for such a pair $$(W',w')$$ to exist. Indeed, let $$V$$ be a """II-winning""" set that contains no $$v$$ such that $$v_i=\gamma_i, v_j=\gamma_j$$ and $$v_h=\gamma_h$$, but does contain $$w$$. Then it is possible that the response of $$\sigma$$ to $$y_i=(\gamma_i,W)$$ is the move $$y_j=(\gamma_j,w)$$ and that the response to any other move $$y_i=(\gamma_i,W')$$ is a move $$y_j=(\gamma_j,w')$$, where $$w'\in V\cap W'$$. I'm not 100% sure that argument is correct, but for now it has given me a fairly strong conviction that the strategy-lifting property really is stronger than the winning-sets-lifting property. Just to clarify this, let's think about what Player II actually does in order to guarantee to produce a sequence that could have resulted from $$\sigma$$. He observes that the set of $$w$$ that could occur as part of his first move $$y_j=(\gamma_j,w)$$ in the auxiliary game is a """II-winning""" set, and plays a winning strategy for getting into that set. What bothers me now is that that seems to lead to a proof that there //is// always some $$W$$ that is consistent with all the moves so far: just play the game to its finish with this winning strategy for Player II, and whatever sequence $$w$$ that results will be the response to some initial $$W$$, which will be consistent with the strategy in the auxiliary game at all stages of the real game. So what is going on here? Which argument is correct? Ah, there is an amusing subtlety here. It is possible that the sequence $$w$$ that results is indeed the reponse of $$\sigma$$ to the initial $$(\gamma_i,W)$$, but that the order in which $$\sigma$$ tells Player II to play the coordinates of $$w$$ is not the same as the order in which they were played in the game in $$X$$.  [encoded data, 13512 characters] /*{{{*/ #sidebar .wizard table { margin: 0px; } #menuBar #sidebarOptions { margin-right: 0.6em; } #sidebarTabs { position: absolute; right: 0; top: 0; width: 22.2em; } .tabset { padding: 1em 6px 1px 0; position: relative; top: 2px; } #sidebarTabs .tabsetWrapper .tabset { float: left; height: auto; display: inline; width: 5.5em; word-wrap: break-word; top: 0; padding: 0 0 1px; } #sidebarTabs .tabsetWrapper .tabsetWrapper .tabset { float: none; height: auto; top: 1px; padding: 0 0 1px; } .tab { margin: 0.1em 0.25em 0 0; padding: 6px 6px 0; display: inline-block; -webkit-border-top-left-radius: 6px; -webkit-border-top-right-radius: 6px; -moz-border-radius-topleft: 6px; -moz-border-radius-topright: 6px; border-top-left-radius: 6px; border-top-right-radius: 6px; } #sidebarTabs .tabsetWrapper .tabset .tab { display: block; margin: 0 0 1px 0.25em; padding: 1em 6px 0.5em; position: relative; left: 3px; border-right: 0; border-bottom: 1px solid [[ColorPalette::TertiaryMid]]; border-color: [[ColorPalette::TertiaryMid]]; -webkit-border-radius: 0; -moz-border-radius: 0; border-radius: 0; } #sidebarTabs .tabsetWrapper .tabsetWrapper .tabset .tab { margin: 0.1em 0.25em 0 0; padding: 6px 6px 0; display: inline-block; border-right: 1px solid [[ColorPalette::TertiaryMid]]; border-bottom: 0; -webkit-border-top-left-radius: 6px; -webkit-border-top-right-radius: 6px; -moz-border-radius-topleft: 6px; -moz-border-radius-topright: 6px; border-top-left-radius: 6px; border-top-right-radius: 6px; } .tabContents { -webkit-border-top-right-radius: 6px; -webkit-border-bottom-left-radius: 6px; -webkit-border-bottom-right-radius: 6px; -moz-border-radius-topright: 6px; -moz-border-radius-bottomright: 6px; -moz-border-radius-bottomleft: 6px; border-top-right-radius: 6px; border-bottom-right-radius: 6px; border-bottom-left-radius: 6px; } #sidebarTabs .tabsetWrapper .tabContents { display: inline; -webkit-border-radius: 0; -moz-border-radius: 0; border-radius: 0; border-width: 1px 1px 1px 3px; float: left; border-color: [[ColorPalette::TertiaryMid]]; *height: expression(this.scrollHeight < 301? "300px" : "auto"); min-height: 25em; background-color: [[ColorPalette::TertiaryPale]]; } #sidebarTabs .tabsetWrapper .tabsetWrapper .tabContents { border-width: 1px; display: block; float: none; min-height: 0; -webkit-border-top-right-radius: 6px; -webkit-border-bottom-left-radius: 6px; -webkit-border-bottom-right-radius: 6px; -moz-border-radius-topright: 6px; -moz-border-radius-bottomright: 6px; -moz-border-radius-bottomleft: 6px; border-top-right-radius: 6px; border-bottom-right-radius: 6px; border-bottom-left-radius: 6px; } /*}}}*/ Suppose that you are working on a mathematical problem. Typically this involves //looking for something//. That something might be a mathematical object, such as a graph, or it might be a metamathematical object, such as a proof or definition. Either way, what one is looking for should have certain properties: for example, you might want a graph with high girth and high chromatic number, or a proof that actually proves the theorem you want to prove, or a definition that will encapsulate just the properties that are important to a certain area of mathematical enquiry. What makes mathematics difficult is that finding objects with certain properties has a strong flavour of an NP problem. Often it is easy to verify that an object has a certain property, but how do you find that object in the first place? (Sometimes even the verification isn't easy, which makes the problem even harder.) Initially it seems quite strange, given that simple observation, that mathematics is possible at all, given that there is no evidence that human brains can solve [[NP-complete problems|http://en.wikipedia.org/wiki/NP-complete]]. However, we have a variety of tricks for narrowing down our mathematical searches. For example, if we are looking for an object with certain properties, then non-uniqueness is often a problem: the properties do not determine the object we are looking for. To counteract this, we often //add// to the properties certain further properties, such as that make the object "more unique": examples are asking for the object to have certain symmetries, asking for it to be maximal, and asking for it to be as simple as possible. This is an example of a standard problem-solving move: it converts the problem into a new problem that may be easier. (I say "may be" because there is judgment involved: sometimes we might add extra properties and find that no object with the original properties and the extra ones exists. But if we discover that, then we have learnt something useful about the original problem.) My aim with this site is to present, for each open problem that I discuss, a collection of interlinked documents related to it. Taken together, these documents will record the current status of my attempts to solve the problem. The main features of the organization is that the documents will be classified into certain types (things like "discussion of mathematical question" or "definition"), and, more importantly, the links will be classified into certain types as well (things like "generalize the question" or "try a simple example"). I have two hopes of this. One is that it will be convenient and even enjoyable to navigate one's way through this vertex- and edge-labelled graph, and that one will be able to look at subquestions in isolation but quickly understand how they are motivated by the original problem. !Page types I shall call the interlinked documents I referred to above //pages//. I want each page to be about one thing, in a sense that I don't quite know how to make precise but that I hope will become precise as I write pages. But to give some idea, if there is a page of discussion about a mathematical question and at some point I think, "Maybe I should try an approach like this," then any further discussion of that approach should take place on another page. Here then, are some tags that will be used to classify pages. !!!"""DiscussQuestion""" A """DiscussQuestion""" page will normally start with a mathematical question. There will be links to any parent pages that have led to this question being asked. There will follow a some discussion. In very simple cases, this discussion might take the form of a complete answer to the question (typically, a proof of our counterexample to some mathematical statement). Much more often, it will contain thoughts like, "In order to answer this question, it might be helpful to answer //this// question first. The new question will then get its own page. There may be several subsidiary pages of this kind. !!!"""Definition""" A """Definition""" page is what it sounds like: a page where I give the definition of something. !!!"""Background""" A Background page is one that discusses some known mathematical definitions and results, famililarity with which will be assumed in several other pages. !Page characteristics !!!"""GlobalPoint""" Suppose you reformulate a problem. While you are thinking about the reformulation, you can forget about the original version of the problem. So in some sense the original formulation is a "local" part of the thought process. By contrast, suppose you think of an example that shows that a certain generalization of what you are trying to prove is false. This counterexample will typically inform all your thinking about the problem: you know that you must avoid any proof method that would, if it worked, establish the more general statement as well. So this is a more "global" kind of insight. The """GlobalPoint""" tag does not indicate a //type// of page, so much as a //property// of certain pages. What it tells the reader is that it is a good idea to remember the content of the page, as it is likely to be referred to on several other pages. !!!"""OpenTask""" On some pages, there are questions that need further thought. I don't want to call them open problems for various reasons: sometimes they are a bit vague, they may not always be difficult, and I have not always carefully checked that they are open. So I use the tag """OpenTask""" to indicate that somewhere on the page is a suggestion for more work that could be done. If you are interested in contributing to this project, then clicking on the """OpenTask""" tag will I hope be a good way of finding out where the incomplete parts of the proof-discovery DAG are. (Just in case you are unfamiliar with the jargon, DAG stands for "directed acyclic graph".) !Link types Now for the important part: the various ways that pages can relate to subsidiary pages. I shall add to this list as the need arises. !!!"""GeneralizeQuestion""" One way of trying to make the task of proving a statement easier is to try to prove a more general statement. At first, this might seem a perverse strategy: surely proving a more general statement should be harder rather than easier. But that is by no means always the case. Sometimes, doing away with some of your assumptions will indeed make the problem harder. However, one thing it always does is //reduce your options//. If you are very lucky, it reduces them to the point where you can solve the problem simply by doing the only thing you can. Generalizing a question can also tidy it up significantly. And even if the generalization turns out to be false, it is very useful to see why it is false, since that may well highlight the features of the more specific problem that you need to use. !!!"""LookForSomethingMoreSpecific""" At first glance, this looks like the exact opposite of """GeneralizeQuestion""", but it is actually a complementary approach. Typically, """GeneralizeQuestion""" concerns universal implications: whenever an object has certain properties, then some statement holds. We can generalize that by cutting down on the properties we assume. This results in our attempting to prove a stronger statement, since our premises have become weaker, but our conclusion is the same as before. """LookForSomethingMoreSpecific""" concerns existential statements. We are trying to find an object with certain properties, but those properties are so general (and maybe not even wholly precise) that we find it hard to know where to start. So we add properties in order to confine our search to a smaller space. For this to be a reasonable move, we need reasons to believe that an object with the additional properties has a chance of existing, and we need the properties we add to be ones that have a chance of simplifying our task. !!!"""TryWeakerQuestion""" This //is// more like the opposite of """GeneralizeQuestion""". Sometimes if a question is too hard to tackle head on, it helps to set one's sights lower and prove something weaker. For example, if you don't see how to prove an exact formula for some quantity, it may be fruitful to obtain a good estimate instead -- or even a not very good, but at least non-trivial, estimate. If you are lucky, this will give you the tools you need for the stronger problem. If not, it may at least give you a better idea of what the true difficulties are. !!!"""LookForSomethingLessSpecific""" This is again a weakening move. If you are trying to find an object with certain properties and don't know how to get started, it is often helpful to aim for a weaker set of properties in the first instance. If, for example, you want an $$x$$ such that $$R(x)$$, and $$P\wedge Q\implies R$$, you might find that you can characterize objects that satisfy $$P$$ in a nice way (or, less ambitiously, find a convenient set of objects that satisfy $$P$$), in which case you will be looking, in your nice set of objects that satisfy $$P$$, for an object that satisfies $$Q$$. !!!"""MoreDetails""" This kind of link is to do with exposition rather than with problem-solving strategies. Sometimes I will make a statement that is not supported in the current page, because I don't want to interrupt the flow, but which is more fully justified in a subsidiary page. !!!"""EvaluateApproach""" Most of the link types above concern the reasons one switches from thinking about one question to thinking about another. But sometimes one doesn't want to rush into thinking about a question: rather, one wants to decide whether the effort is likely to be worthwhile. !!!"""TryToMakeQuestionMorePrecise""" Often one basically knows what the question is, but one doesn't know //exactly// how to formulate it. If we switch to a more precise version of the question, then that would probably count as an instance of """LookForSomethingMoreSpecific""". But if the object of the new page is to //find// the more precise question, then the link type is """TryToMakeQuestionMorePrecise""". !!!"""ClarifyConcept""" Sometimes you're dealing with some newish concept and you realize that there is a fairly simple question about it that you don't know the answer to. You're not sure how the answer to that question would help, but it feels wrong not to think about it. !!!"""TryToFormulateDefinition""" This is a different kind of clarification of concept. One has a vague idea of what one hopes will be achieved by a definition, but one lacks the definition itself. So one tries to find a definition that will make the arguments work. !!!"""CheckGuess""" Sometimes one is trying to find an object with certain properties and one comes up with a candidate that looks as though it might work. And sometimes it is not completely obvious whether it works or not. In that case, determining whether it works becomes a new question to think about. !!!"""GeneralizeCounterexample""" Suppose you are trying to prove a result in a certain way and a lemma you were hoping for turns out to be false. A good thing to do at that point is to try to understand in full generality what has gone wrong. That is, you don't stop just at the knowledge that one particular lemma is false: you try to generalize the counterexample as much as you can, so that you will gain as much knowledge as possible about what can and can't work. !!!"""TryToProveTheOpposite""" Sometimes when you are trying to prove a statement it can be a good idea to switch to trying to prove its negation instead. If you //do// prove the negation, then obviously that is important, since it tells you to stop trying to prove the original statement. But another possibility is that you run into difficulties when you try to prove the negation, and those difficulties become the seed for a proof of the statement you originally wanted. This tactic can work in two ways: if you are trying to find an example, then it can be helpful to try to show that no such example exists, and if you are trying to prove a general statement, then it can be helpful to look for a counterexample. /*** |''Name''|BinaryUploadPlugin| |''Version''|0.3.16| |''Author''|Ben Gillies and Jon Robson| |''Type''|plugin| |''Source''|http://github.com/TiddlySpace/tiddlyspace/raw/master/src/plugins/BinaryUploadPlugin.js| |''Description''|Upload a binary file to TiddlyWeb| |''CoreVersion''|2.6.1| |''Requires''|TiddlySpaceConfig TiddlyWebConfig| !Usage {{{ <<binaryUpload bag:<name> edit:tags edit:title tags:<default tags> title:<title> >> }}} * {{{bag:<name>}}}: optional; if left out, the file will be saved to the current workspace * {{{edit:tags}}}: specifies that you want to tag the file being uploaded * {{{edit:title}}}: specifies that you want to set the title to something other than the filename * {{{tags:<default tags>}}}: specifies a default set of tags to apply to the file (requires {{{edit:tags}}} to be set) * {{{title:<title>}}}: predefines the title of the binary tiddler !Requires TiddlyWeb tiddlywebplugins.form !Code ***/ //{{{ (function($) {

var tiddlyspace = config.extensions.tiddlyspace;

var macro = config.macros.binaryUpload = {
locale: {
titlePrefix: "title: ",
tagsPrefix: "tags: ",
},
renderInputFields: function(container, options) {
var locale = macro.locale;
var editableFields = options.edit;
var includeFields = {
tags:  editableFields && editableFields.contains("tags") ? true : false,
title: editableFields && editableFields.contains("title") ? true : false
};
var fields = ["title", "tags"];
for(var i = 0; i < fields.length; i++) {
var fieldName = fields[i];
var userDefault = options[fieldName];
var defaultValue = userDefault ? userDefault[0] : false;
if(includeFields[fieldName] || defaultValue) {
var localeDefault = locale["%0DefaultValue".format(fieldName)];
var className = defaultValue ? "userInput" : "userInput notEdited";
var inputEl;
var val = defaultValue || localeDefault || "";
var iContainer = $("
").addClass("binaryUpload%0".format(fieldName)). appendTo(container); if(defaultValue && !includeFields[fieldName]) { var label = locale["%0Prefix".format(fieldName)];$("").text(label).appendTo(iContainer);
$("").addClass("disabledInput").text(val).appendTo(iContainer); inputEl =$("<input />").attr("type", "hidden");
} else {
inputEl = $("<input />").attr("type", "text"); } inputEl.attr("name", fieldName). addClass("%0Edit".format(fieldName)). val(val).addClass(className).appendTo(iContainer); } } }, getTiddlerName: function(fileName) { var fStart = fileName.lastIndexOf("\\"); var fStart2 = fileName.lastIndexOf("/"); fStart = fStart < fStart2 ? fStart2 : fStart; fileName = fileName.substr(fStart+1); return fileName; }, errorHandler: function(fileName) { displayMessage("upload of file %0 failed".format(fileName)); }, uploadFile: function(place, baseURL, workspace, options) { var pleaseWait =$(".uploadProgress", place);
var iframeName = options.target;
var form = $("form", place); var existingVal =$("input[name=title]", form).val();
var fileName = existingVal || $('input:file', form).val(); if(!fileName) { return false; // the user hasn't selected a file yet } fileName = macro.getTiddlerName(fileName);$("input[name=title]", place).val(fileName);
// we need to go somewhere afterwards to ensure the onload event triggers
var redirectTo = "/%0/tiddlers.txt?select=title:%1".
format(workspace, fileName);
var token = tiddlyspace ? tiddlyspace.getCSRFToken() : "";
var action = "%0?csrf_token=%1&redirect=%2"
.format(baseURL, token, redirectTo);
form[0].action = action; // dont use jquery to work with ie
form[0].target = iframeName;
// do not refactor following line... won't work in IE6 otherwise
$(place).append($('').css('display','none'));
var content = document.getElementById(iframeName).contentWindow.document.documentElement;
if($(content).text().indexOf(fileName) > -1) { options.callback(place, fileName, workspace, baseURL); } else { macro.errorHandler(fileName); } form.show(1000); pleaseWait.hide(1000); }); form.hide(1000); pleaseWait.show(1000); return true; }, createUploadForm: function(place, options) { var locale = macro.locale; if(readOnly) {$('
').text(locale.membersOnly).
appendTo(place);
return;
}
var bag = options.bag;
options.callback = options.callback ? options.callback :
function(place, fileName, workspace, baseurl) {
macro.displayFile(place, fileName, workspace);
$("input[type=text]", place).val(""); }; var defaults = config.defaultCustomFields; place =$("
").addClass("container").appendTo(place)[0];
var workspace = bag ? "bags/%0".format(bag) : config.defaultCustomFields["server.workspace"];
var baseURL = defaults["server.host"];
baseURL += (baseURL[baseURL.length - 1] !== "/") ? "/" : "";
baseURL = "%0%1/tiddlers".format(baseURL, workspace);
//create the upload form, complete with invisible iframe
// do not refactor following line of code to work in IE6.
var form = $('<form action="%0" method="POST" enctype="multipart/form-data" />'. format(baseURL)).addClass("binaryUploadForm"). appendTo(place)[0]; macro.renderInputFields(form, options);$(form).
submit(function(ev) {
this.target = iframeName;
options.target = iframeName;
})
.find('[type="file"]').bind('change', function() {
$(form).find('[type="submit"]').prop('disabled', false); }).end();$('
').addClass("uploadProgress").text(locale.uploadInProgress).hide().appendTo(place);
$("input[name=file]", place).change(function(ev) { var target =$(ev.target);
var fileName = target.val();
var title = $("input[type=text][name=title]", place); if(!title.val()) { title.val(fileName); } }); }, handler: function(place, macroName, params, wikifier, paramString, tiddler) { params = paramString.parseParams(null, null, true); macro.createUploadForm(place, params[0]); }, iFrameLoader: function(iframeName, callback) { var iframe = document.getElementById(iframeName); //jQuery doesn't seem to want to do this!? var locale = macro.locale;$(".userInput").addClass("notEdited"); // reset editing
callback();
};
return;
};

//IE
}
};
},
displayFile: function(place, title, workspace) {
var context = {
workspace: workspace,
host: config.defaultCustomFields['server.host']
};
if(context.status) {
story.displayTiddler(place, title);
var image = config.macros.image;
if(image && image.refreshImage) {
image.refreshImage("/%0/tiddlers/%1".format(workspace, title));
image.refreshImage(title);
image.refreshImage("/%0".format(title));
image.refreshImage("%0/%1/tiddlers/%2".format(config.extensions.tiddlyweb.host, workspace, title));
}
} else {
}
});
}
};

if(tiddlyspace) {
handler: function(place, macroName, params, wikifier, paramString, tiddler) {
var options = paramString.parseParams(null, null, true)[0];
var bag = tiddlyspace.getCurrentBag("public");
options.bag = bag;
}
};
config.messages.privacySetting = config.options.chkPrivateMode ?
"private" : "public";
getCurrentWorkspace(config.messages.privacySetting);
}

})(jQuery);
//}}}
<!DOCTYPE html>

<meta charset="utf-8"/>
<title>TiddlySpace Apps</title>

manage space

BROWSE

TIDDLYWIKI

an easy to understand HTML representation of your content.

use TiddlyWiki to create, edit and organise your content.

blog
featured
documentation
source

TiddlySpace 2011, created by Osmosoft

!!Parent pages

We are trying to [[find a satisfactory definition of "half-dimensional sets"|What is the right definition of a "half-dimensional set"?]].

While thinking about [[the relationship between complexity structures and the invariant game|What is the difference between this set-up and the invariant game?]] I had an (obvious in retrospect) idea.

!Introduction

The set $$\{0,1\}^n$$ comes with a natural class of "neighbourhoods": sets of the form $$\{x:x_{i_1}=\epsilon_1,\dots,x_{i_k}=\epsilon_k\}$$ (that is, sets where you specify $$k$$ of the coordinates and nothing else). I call a neighbourhood $$k$$-//basic// if $$k$$ coordinates are specified.

These neighbourhoods naturally form a DAG: you put an arrow from each $$k$$-basic neighbourhood to all the $$(k+1)$$-basic neighbourhoods it contains.

One can play a game on a DAG in an obvious way: the players take turns going from the current vertex to one of its (out-) neighbours. However, if one is careless with one's definitions, then this effectively unwraps the DAG into a tree (its "universal cover"). To avoid that, one can define a strategy to be a way of deciding where to move next that is "memoryless" in the sense that //it depends only on the current vertex//.

!If we do that, then what is the natural analogue of a strategic subtree?

What I really want is an analogue of //the set of leaves// of a strategic subtree. I want to say that $$A$$ is //a win for Player I// if for every 1-basic set $$B_1$$ there exists a 2-basic subset $$B_2$$ such that for every 3-basic subset $$B_3$$ there exists ... such that for every $$(n-1)$$-basic subset $$B_{n-1}$$ there exists a point $$x\in A\cap B_{n-1}$$.

OK, that just means that Player I has a winning strategy for the game where you shrink neighbourhoods gradually, which is reminiscent of [[Schmidt's game|http://mathoverflow.net/questions/137196/winning-sets-of-full-measure-schmidts-game]]. I've just noticed that Player I has a winning strategy for this game if and only if she has a winning "memoryless" strategy, so some of what I said above is a slight red herring. <<slider chkProofOfMemorylessness "Proof of equivalence" "Proof" "Proof of equivalence">>

This is sufficiently natural that I think it is worth adopting as a candidate definition of a half-dimensional set. Actually of course, we need two definitions, since there are winning sets for Player I and winning sets for Player II. The determinacy of finite games gives us the Ramsey property instantly, and it is also instant that every winning set for Player I intersects every winning set for Player II.

!Why does this definition avoid the problem we were having with the [[obvious invariant game|Can we find an analogue of Martin's theorem using the obvious invariant game?]]?

The problem we had before was that the assertion "Player I has a winning strategy for the set $$A$$" was invariant under automorphisms of the game tree, as were the assertions we were thinking about to do with lifting games. We wanted coordinate hyperplanes to be simple, but that implied that any image of a coordinate hyperplane under an automorphism of the game tree should be simple, as should small Boolean combinations of those images. And it looked very much as though that would give us all sets of leaves.

What is stopping precisely that argument from applying here? The game seems to be the same one. I think the answer is that we are identifying leaves in the game tree and are not allowing ourselves to do anything that does not respect that identification. So the complicated sets that could be constructed before using tree automorphisms can no longer be constructed, and every lift we talk about must lift equivalence classes of leaves rather than individual leaves.

All this strikes me as good news, since it appears to get rid of the aspect of the games picture that was troublesome -- the problems associated with dealing with concepts that are tree-automorphism-invariant -- without throwing away the notion of a game entirely. That makes me more confident that we are on the track of a possible "right" finitization of Martin's theorem.

[[Return to principal parent page|What is the right definition of a "half-dimensional set"?]]

!!Parent page

I got stuck trying to work out [[whether an arbitrary set can be Ramsey lifted|Can all sets be Ramsey lifted?]].

!Introduction

The grandparent of this page is called [[What is the right definition of a "half-dimensional set"?]], so what is different about this page? It's that what I am trying to do here is a little less ambitious: rather than actually formulating a definition, I want to think about a couple of questions related to it.

In the grandparental page, I expressed the desired features of the definition in terms of //distances//. It has subsequently occurred to me that this may not be a very natural thing to do. It now seems to me that the "topology" on $$\{0,1\}^n$$ is "not metrizable" and that our definitions should reflect this. What I mean is that the "basic open sets" in the "product topology" on $$\{0,1\}^n$$ (the inverted commas here are to emphasize that I am speaking imprecisely and analogically rather than using correct definitions -- strictly speaking what we are dealing with here is the discrete topology, but I want to regard certain sets as "more open" than others) are very different from the "basic open sets" that come from the Hamming metric. In the former case they are the sets you obtain by restricting a few coordinates, whereas in the latter they are Hamming balls. An additional advantage of the restrictions definition is that the basic open sets can be nicely partitioned into smaller basic open sets.

Although I wasn't trying to do this, here is a proposal for a definition of "half dimensional".

''Definition.'' If $$X\subset\Gamma^n$$ is a complexity structure, define $$X(*)$$ to be the set of all sequences $$y\in(\Gamma\cup\{*\})^n$$ such that there exists $$x\in X$$ with the property that $$y_i=x_i$$ or $$y_i=*$$ for every $$i$$. In other words, $$X(*)$$ consists of sequences obtained by taking a sequence in $$X$$ and replacing some of its coordinates by asterisks. Equivalently, it is the set of partially defined sequences that can become sequences in $$X$$ if you choose values in $$\Gamma$$ for the asterisks. Let $$A\subset X$$. We inductively define $$A$$ to be //half dimensional with respect to// a partially defined sequence $$x$$ in the following way.
*If there are no asterisks in $$x$$, then $$A$$ is half dimensional with respect to $$x$$ if and only if $$x\in A$$.
*If there is at least one asterisk in $$x$$, then $$A$$ is half dimensional with respect to $$x$$ if and only if for at least half the possible sequences $$z$$ that can be obtained from $$x$$ by specifying one further asterisk, $$A$$ is half dimensional with respect to $$z$$.
Finally, we say that $$A$$ is //half dimensional// if $$A$$ is half dimensional with respect to the all-asterisks sequence.

We can think of the above definition as a first guess in a process of """GuessAndAdjust""".

!Stress testing the initial guess

The thing that looks least convincing about the above definition is "at least half the possible sequences $$z$$ that can be obtained from $$x$$ by specifying one further asterisk". If $$X$$ is a nice symmetrical complexity structure like $$\Gamma^n$$, then it's probably fine, but what if $$X$$ is a set $$\Gamma_1\times\dots\times\Gamma_n$$ with the $$Gamma_i$$ of very different sizes, or, even worse, what if $$X$$ is something like a tree? In both these cases, it looks as though strange things happen. In the first case, if, say, $$\Gamma_n$$ is far bigger than all the other $$\Gamma_i$$, then for any sequence $$x$$ with an asterisk in the last coordinate, almost all $$z$$ that you can obtain from $$x$$ will be obtained by specifying the $$n$$th coordinate. Somehow that doesn't feel right. And in the tree case, a partially specified path is in fact completely specified up to its final non-asterisk. So for asterisks that appear earlier than this, there is only one way of specifying them, which nevertheless counts in the definition above (which is pretty odd), and for asterisks that appear later, the later they appear, the more of the sequence they determine. What's more, there are far more ways of specifying the later asterisks, so the definition gives a great deal of weight to ways of specifying almost the entire sequence, which is not really what we want. ''//Open Task: continue thinking about this and come up with a more convincing guess.//''

/***
|''Name''|TiddlySpaceInitialization|
|''Version''|0.7.3|
|''Description''|Initializes new TiddlySpaces the first time they are created|
|''Status''|@@beta@@|
|''Source''|http://github.com/TiddlySpace/tiddlyspace/blob/master/src/plugins/TiddlySpaceInit.js|
|''CoreVersion''|2.6.1|
|''Requires''|TiddlySpaceConfig RandomColorPalettePlugin chrjs ImageMacroPlugin|
!TODO
* robust error notification and recovery

type="application/atom+xml" title="%0's public feed" />

!Code
***/
//{{{
(function($) { var versionField = "tiddlyspaceinit_version"; var markupPreHead = store.getTiddlerText(tiddler.title + "##MarkupPreHead", ""); var tiddlyspace = config.extensions.tiddlyspace; var currentSpace = tiddlyspace.currentSpace; var tweb = config.extensions.tiddlyweb; var plugin = config.extensions.TiddlySpaceInit = { version: "0.6", SiteTitle: "%0", SiteSubtitle: "a TiddlySpace", flagTitle: "%0SetupFlag", flagWarning: "Please do not modify this tiddler; it was created " + "automatically upon space creation.", dispatch: function(ev) { var title = plugin.flagTitle.format([currentSpace.name]); config.annotations[title] = plugin.flagWarning; if(currentSpace.type != "private") { return; } var tiddlers = []; var tid = store.getTiddler(title); if(tid) { curVersion = parseFloat(tid.fields[versionField]); reqVersion = parseFloat(plugin.version); if(curVersion < reqVersion) { plugin.update(curVersion, tid); tid.fields[versionField] = plugin.version; tid.incChangeCount(); tid = store.saveTiddler(tid); tiddlers.push(tid); } } else { // first run tid = new Tiddler(title); tid.tags = ["excludeLists", "excludeSearch", "excludePublisher"]; tid.fields =$.extend({}, config.defaultCustomFields);
tid.fields[versionField] = plugin.version;
tid.text = "@@%0@@".format([plugin.flagWarning]);
tid = store.saveTiddler(tid);
tiddlers = tiddlers.concat(plugin.firstRun(), tid);
}
autoSaveChanges(null, tiddlers);
},
update: function(curVersion, flagTiddler) {
if(curVersion < 0.2) {
this.createAvatar();
}
if(curVersion < 0.3) {
flagTiddler.tags.pushUnique("excludePublisher"); // XXX: never persisted
}
if(curVersion < 0.5) { // v0.4 was faulty
}
if(curVersion < 0.6) {
this.purgeSystemSettings();
}
},
pubTid: {
tags: ["excludeLists", "excludeSearch"],
fields: $.extend({}, config.defaultCustomFields, { "server.workspace": tiddlyspace.getCurrentWorkspace("public") }) }, makeTiddlerIfNot: function(tiddler) { if (!store.tiddlerExists(tiddler.title)) {$.extend(true, tiddler, plugin.pubTid);
return [store.saveTiddler(tiddler)];
} else {
return [];
}
},
firstRun: function() {
var tiddlers = [];
// generate Site*itle
$.each(["SiteTitle", "SiteSubtitle"], function(i, item) { var tid = new Tiddler(item); tid.text = plugin[item].format([currentSpace.name]); tiddlers.push.apply(tiddlers, plugin.makeTiddlerIfNot(tid)); }); // generate public ColorPalette var tid = new Tiddler("ColorPalette"); tid.text = config.macros.RandomColorPalette.generatePalette({ saturation_pale: 0.67, saturation_light: 0.53, saturation_mid: 0.43, saturation_dark: 0.06, pale: 0.99, light: 0.85, mid: 0.5, dark: 0.31 }, false); tiddlers.push.apply(tiddlers, plugin.makeTiddlerIfNot(tid)); this.createAvatar(); this.setupMarkupPreHead(); return tiddlers; }, // remove _cookie slices (TiddlyWiki 2.6.2 beta 6 remnants) purgeSystemSettings: function() { var ss = store.getTiddler("SystemSettings"); if(ss) { var lines = ss.text.split("\n"); var persistentOptions =$.grep(lines, function(line, i) {
});
ss.text = persistentOptions.join("\n");
ss = store.saveTiddler(ss);
autoSaveChanges(null, [ss]);
}
},
createAvatar: function() {
var avatar = "SiteIcon";
var host = tweb.host;
var notify = function(xhr, error, exc) {
displayMessage("ERROR: could not create avatar - " + // TODO: i18n
"%0: %1".format([xhr.statusText, xhr.responseText]));
// TODO: resolve!?
};

var pubBag = tiddlyspace.getCurrentBag("public");
var tid = new tiddlyweb.Tiddler(avatar);
tid.bag = new tiddlyweb.Bag(pubBag, host);

var callback = function(data, status, xhr) {}; // avatar already exists; do nothing
var errback = function(xhr, error, exc) {
if(xhr.status != 404) {
return;
}
// copy default avatar
var _notify = function(tid, status, xhr) {
displayMessage("created avatar"); // TODO: i18n
var image = config.macros.image;
if(image && image.refreshImage) {
var uri = "/%0/tiddlers/SiteIcon".
format(tiddlyspace.getCurrentWorkspace("public"));
image.refreshImage(uri);
image.refreshImage("SiteIcon");
}
};
var _callback = function(tid, status, xhr) {
tid.title = avatar;
tid.bag.name = pubBag;
delete tid.etag;
};
tweb.getUserInfo(function(user) {
var avatarTitle = currentSpace.name == user.name ?
"defaultUserIcon" : "defaultSiteIcon";
var tid = new tiddlyweb.Tiddler(avatarTitle);
tid.bag = new tiddlyweb.Bag("common", host);
tid.get(_callback, notify);
});
};
tid.get(callback, errback);
},
savePublicTiddlerText: function(title, text, pubWorkspace) {
var tid = new Tiddler(title);
tid.text = text;
tid.tags = ["excludeLists"];
tid.fields = $.extend({}, config.defaultCustomFields); tid.fields["server.workspace"] = pubWorkspace; tid.fields["server.page.revision"] = "false"; tid = store.saveTiddler(tid); autoSaveChanges(null, [tid]); }, setupMarkupPreHead: function() { var pubWorkspace = tiddlyspace.getCurrentWorkspace("public"); var existing = store.getTiddler("MarkupPreHead"); if(!existing || existing.fields["server.workspace"] != pubWorkspace) { var context = this; tweb.getStatus(function(status) { var text = markupPreHead.format(currentSpace.name, tiddlyspace.getHost(status.server_host, currentSpace.name)); context.savePublicTiddlerText("MarkupPreHead", text, pubWorkspace); }); } // also set up DefaultTiddlers var title = "DefaultTiddlers"; existing = store.getTiddler(title) || new Tiddler(title); if(existing.fields["server.workspace"] != pubWorkspace) { var text = existing.text || store.getShadowTiddlerText(title); this.savePublicTiddlerText(title, text, pubWorkspace); } } };$(document).bind("startup", plugin.dispatch);

})(jQuery);
//}}}
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
!!Parent page

We are considering [[how we might show that sets of low circuit complexity can be more efficiently lifted than random sets|What do we need in order to show that sets of low circuit complexity can be efficiently lifted?]].

!Introduction

We have come to the conclusion (at the end of [[this page|How easy is it to lift a 2-basic set to a 1-basic set?]] that we are not going to achieve what we want by finding an efficient lifting that converts a 2-basic set into a 1-basic set. The problem is that if we could do that, then we would be able to lift all Boolean combinations of the first $$n/2$$ coordinate hyperplanes simultaneously and efficiently.

However, this does not (yet?) kill off the entire approach, because if we could prove what we want to prove by lifting 2-basic sets to 1-basic sets, then we would be doing something quite a lot stronger than Martin did in his proof. So an optimistic view would be that this may indicate that we need to try harder to imitate Martin's proof.

!Is there any hope of imitating Martin's proof?

There are a number of pretty serious challenges we face if we want to imitate Martin's proof. Let me try to enumerate them, in no particular order.

!!!What should we take for $$k$$?

Our aim is to prove that every closed set can be efficiently lifted to an open set, in some sense of "closed" and "open". The best candidate we have so far for that sense is $$k$$-closed and $$k$$-open for some $$k$$. But then we need to decide what value to take for $$k$$. Natural candidates are 1, 2 and some slow-growing function of $$n$$.

!!!Why doesn't Martin's proof trivially fail us?

Martin lifts to a game where Player I's first move is to declare a point and a quasistrategy. The quasistrategy can be arbitrary, so it would seem that the natural finite analogue already involves jumping to an alphabet of doubly exponential size.

Worse still, this process is iterated, so one might expect a natural finitary analogue to yield lifts with alphabets of tower size.

Worse even than that, there are results that show that the enormous sets that arise in Martin's proof are in some sense necessary. Therefore, we cannot afford to find a finitary analogue that would itself have an infinitary analogue that was significantly simpler than Martin's construction.

!Is there any way round the second set of observations?

I don't know the answer to this, but I have a couple of slightly less pessimistic thoughts. One is that I realized recently that we can afford to have the size of the alphabet go up by a //doubly exponential// factor. Indeed, recall (from the conclusion of [[this page|Is there a realistic proposal for how an eventual proof might look?]]) that if the size of the alphabet goes up by $$2^{f(n)}$$ at each lift, and the lower bound for random functions (or some NP function) is $$2^{g(n)}$$, then we distinguish between functions of circuit complexity less than $$g(n)/f(n)$$ and random functions (or that NP function). So it is enough if $$g(n)$$ is one exponential function and $$f(n)$$ is another with a smaller exponent.

Another is that we know that the "lower bounds" for the cardinals needed to prove Borel determinacy do not have analogues in the finite case, since we have a doubly exponential lift that works for all sets. So it is possible that Martin's proof won't give us an efficient lift that works for sets of low circuit complexity, but that the truth of the matter is that //some// efficient lift exists.

That leaves the first problem: that the very first thing Martin lets Player I do in the auxiliary game is declare a quasistrategy. However, I have some hope (together with plenty of scepticism about the hope) that it may be possible to analyse Martin's proof carefully and show that in the finite set-up we do not need to consider all the strategies that Martin considers.

The reason I am sceptical about that hope is that we can't really afford to multiply the size of the alphabet by something that depends on the size of the alphabet. For example, if we square the size of the alphabet each time, then after $$m$$ steps we reach an alphabet of size $$2^{2^m}$$, which means that we cannot say anything about sets of superlinear circuit complexity (a wearily familiar situation). So if we are going to cut down the number of strategies we consider, we are going to have to do so in a rather drastic way. But then we're in danger of trying to find a proof of a kind that doesn't exist, since it would suggest that in the infinite case one could multiply the size of the alphabet by $$2^{\aleph_0}$$ at each stage, when in fact we can't.

!What next?

Just at the moment, the one thing I can think of to try is going back to the iterative approach to designing a lift that I abandoned while writing [[this post|Can we find a Ramsey lift by an iterative procedure?]]. Part of the task will be working out what exactly the iterative approach is, though I have a reasonably good rough idea.

So here goes. [[LookForSomethingMoreSpecific|Can we find an efficient lift by imitating Martin's proof and using an iterative procedure?]]

/***
|''Description:''|Formatter to reference other spaces from wikitext |
|''Author:''|PaulDowney (psd (at) osmosoft (dot) com) |
|''Version:''|1.4.2|
|''~CoreVersion:''|2.4|
!!Documentation
This plugin provides wikitext formatters for referencing another [[space|Space]] on the same TiddlySpace server, as in the following examples:
<<<
{{{@space}}} -- @space
{{{~@space}}} -- ~@space
{{{Tiddler@space}}} -- Tiddler@space
{{{[[Tiddler Title]]@space}}} -- [[Tiddler Title]]@space
<<<
Links to tiddlers with a title begining with an "@" remain as tiddlyLinks:
<<<
{{{[[@tiddler]]}}} -- [[@tiddler]]
<<<
and these may be changed into a space link using {{{@@}}}:
<<<
{{{[[@@space]]}}} -- [[@@space]]
{{{[[@space|@@space]]}}} -- [[@space|@@space]]
<<<
TiddlySpace includes the [[TiddlySpaceLinkPlugin]] which provides WikiText markup for linking to other spaces on the same server. For example @glossary is a link to the {{{glossary}}} space and [[Small Trusted Group]]@glossary a link to an individual tiddler in the @glossary space. Prefixing the link with a tilde escapes the link, for example {{{~@space}}}.
!!Features
The plugin provides external links decorated so that other plugins may be included to add features such as the ability to dynamically pull externally linked tiddlers into the current TiddlyWiki.
Wikitext linking to a space on another server, for example from a tiddler in a space on tiddlyspace.com to a tiddler or a space on example.com, isn't currently supported.
!!Code
***/
//{{{
/*jslint onevar: false nomen: false plusplus: false */

function createSpaceLink(place, spaceName, title, alt, isBag) {
try {
if (spaceName === config.extensions.tiddlyspace.currentSpace.name) {
title = title || spaceName;
jQuery(a).text(alt || title);
return a;
}
} catch (ex1) {
currentSpaceName = false;
}

if(title) {
jQuery(a).attr('tiddler', title);
}
if(isBag) {
jQuery(a).attr('bag', spaceName);
} else {
jQuery(a).attr('tiddlyspace', spaceName);
}

config.extensions.tiddlyweb.getStatus(function(status) {
if (title) {
label = alt || title;
} else {
label = alt || spaceName;
}
// assumes a http URI without user:pass@ prefix
if(!isBag) {
} else {
link += "/bags/" + spaceName + "/tiddlers.wiki";
}
});
return a;
}

(function ($) { config.textPrimitives.spaceName = "[a-zA-Z][a-zA-Z0-9-]*[a-zA-Z0-9]"; config.textPrimitives.spaceNameStrict = "[a-z][a-z0-9-]*"; config.textPrimitives.bareTiddlerLetter = config.textPrimitives.anyLetterStrict; config.formatters.splice(0, 0, { name: "spacenameLink", match: config.textPrimitives.unWikiLink + "?" + config.textPrimitives.bareTiddlerLetter + "*@" + config.textPrimitives.spaceName + "\\.?.?", lookaheadRegExp: new RegExp(config.textPrimitives.unWikiLink + "?(" + config.textPrimitives.bareTiddlerLetter + "*)@(" + config.textPrimitives.spaceName + ")", "mg"), handler: function (w) { if (w.matchText.substr(w.matchText.length - 2, 1) === '.' && w.matchText.substr(w.matchText.length - 1, 1).match(/[a-zA-Z]/)) { w.outputText(w.output, w.matchStart, w.nextMatch); return; } if (w.matchText.substr(0, 1) === config.textPrimitives.unWikiLink) { w.outputText(w.output, w.matchStart + 1, w.nextMatch); return; } this.lookaheadRegExp.lastIndex = w.matchStart; var lookaheadMatch = this.lookaheadRegExp.exec(w.source); if (lookaheadMatch && lookaheadMatch.index === w.matchStart) { createSpaceLink(w.output, lookaheadMatch[2], lookaheadMatch[1]); w.nextMatch = this.lookaheadRegExp.lastIndex; } } }, { name: "tiddlySpaceLink", match: "\$\\[[^\\|\$]*\\|*@@" + config.textPrimitives.spaceName + "\\]", lookaheadRegExp: new RegExp("\$\\[(.*?)(?:\\|@@(.*?))?\$\\]", "mg"), handler: function (w) { this.lookaheadRegExp.lastIndex = w.matchStart; var lookaheadMatch = this.lookaheadRegExp.exec(w.source); if (lookaheadMatch && lookaheadMatch.index === w.matchStart) { var alt = lookaheadMatch[2] ? lookaheadMatch[1] : lookaheadMatch[1].replace(/^@@/, ""); var space = lookaheadMatch[2] || alt; createSpaceLink(w.output, space, "", alt); w.nextMatch = this.lookaheadRegExp.lastIndex; } } }, { name: "tiddlyLinkSpacenameLink", match: "\$\\[[^\\[]*\$\\]@", lookaheadRegExp: new RegExp("\$\\[(.*?)(?:\\|(.*?))?\$\\]@(" + config.textPrimitives.spaceName + ")", "mg"), handler: function (w) { this.lookaheadRegExp.lastIndex = w.matchStart; var lookaheadMatch = this.lookaheadRegExp.exec(w.source); if (lookaheadMatch && lookaheadMatch.index === w.matchStart) { var title = lookaheadMatch[2] || lookaheadMatch[1]; var alt = lookaheadMatch[1] || lookaheadMatch[2]; createSpaceLink(w.output, lookaheadMatch[3], title, alt); w.nextMatch = this.lookaheadRegExp.lastIndex; } } }); // ensure space links don't appear as missing links config.textPrimitives.brackettedLink = "\$\\[([^\$][^@\\]][^\\]]*)\\]\\](?=[^@])"; config.textPrimitives.titledBrackettedLink = "\$\\[([^\\[\$\\|]+)\\|([^\$\$\\|]+)\\]\\](?=[^@])"; // reevaluate derrived expressions .. config.textPrimitives.tiddlerForcedLinkRegExp = new RegExp("(?:" + config.textPrimitives.titledBrackettedLink + ")|(?:" + config.textPrimitives.brackettedLink + ")|(?:" + config.textPrimitives.urlPattern + ")","mg"); config.textPrimitives.tiddlerAnyLinkRegExp = new RegExp("("+ config.textPrimitives.wikiLink + ")|(?:" + config.textPrimitives.titledBrackettedLink + ")|(?:" + config.textPrimitives.brackettedLink + ")|(?:" + config.textPrimitives.urlPattern + ")","mg"); // treat space links in titledBracketedLink as external links var missingTiddlySpaceLink = new RegExp("^@@" + config.textPrimitives.spaceName + "$", "");
};

}(jQuery));
//}}}
!!Parent page

We are trying to [[find a way of Ramsey lifting an arbitrary set|Can all sets be Ramsey lifted?]].

!Introduction

An arbitrary subset of a tree $$T$$ can be lifted to a subset of a tree $$T'$$ in such a way that the corresponding game is decided after two moves. In fact, all sets can be simultaneously lifted in this way. The proof is given in the section "A trivial upper bound" of [[this page|Can games with low-complexity payoff sets be lifted to not much larger games with payoff sets that are closed and open?]]. I would like to imitate that construction with half-dimensional sets replacing strategic subtrees.

!First attempt

In the games case we replaced the first move on $$T$$ by a move for Player I that chooses an arbitrary strategy. The most obvious analogue of that that I can think of is to make the alphabet for the first coordinate of points in $$X$$ consist of all half-dimensional sets. Then Player II chooses a sequence compatible with the strategy, which is the same as choosing a sequence that belongs to the corresponding strategic tree. So here we might make the second coordinate of a typical point in $$X$$ be some point that belongs to the set labelled by the first coordinate.

So $$X$$ could be the set of sequences $$U,x,x_3,\dots,x_n$$ such that $$U$$ is a half-dimensional subset of $$\{0,1\}^n$$, $$x$$ is a point in $$U$$, and $$x=(x_1,x_2,\dots,x_n)$$. Then $$\pi$$ takes this sequence to $$x$$.

A potential problem here is that it is not clear that $$U$$ determines $$x_1$$, so one of the conditions for a lift looks as though it fails. (In fact, by symmetry it seems unlikely that a general half-dimensional set would determine the first coordinate, since why would it not then determine all the other coordinates?) Let us ignore that problem for the time being.

What would a half-dimensional subset of $$X$$ look like? If we want to imitate the proof for games and trees, we would want at least the following kinds of subsets to be half dimensional:
*any subset of the form $$\{y\in X:y_1=U\}$$;
*any subset of the form $$\{y\in X:y_2=f(y_1)\}$$ where for every possible $$y_1$$, $$f(y_1)$$ is a point in $$y_1$$. (Recall that $$y_1$$ is a half-dimensional subset of $$\{0,1\}^n$$.)
The image of a set of the first type is just $$U$$. The image of a set of the second type is an arbitrary transversal of the set of half-dimensional subsets of $$\{0,1\}^n$$, and the Ramsey property of half-dimensional sets implies that any such transversal contains a half-dimensional set.

!Is that too complicated?

What about just taking $$X$$ to be the set of all sequences of the form $$((U,x_1),x_2,\dots,x_n)$$, where $$U$$ is a half-dimensional set and $$x=(x_1,\dots,x_n)\in U$$? Ah, that doesn't work, because it doesn't make an arbitrary set simple when we lift to it.

Or what about points of the form $$(x,x_1),x_2,\dots,x_n)$$, where $$x=(x_1,\dots,x_n)$$? This time there doesn't seem to be much prospect of half-dimensional sets mapping to half-dimensional sets. Or does there? It would be so much easier to think about this sort of question if I had a decent definition to work with.
@@Please do not modify this tiddler; it was created automatically upon space creation.@@
!!Parent page

We are trying to [[find an interesting example of a Ramsey lift|Are there some interesting examples of efficient Ramsey lifts?]].

!Introduction

This page is an attempt to do the following. Given a complexity structure $$X$$, we would like to find a non-trivial Ramsey lift $$\pi:Y\to X$$ such that the alphabet of $$Y$$ is no more than $$C$$ times as large as the alphabet of $$X$$. If we can do this, it may be quite worrying -- though how worrying depends on how easily it can be done and on what "non-trivial" means.

!Trivial examples

Let $$X\subset\Gamma^n$$ and let $$\phi:\Theta\to\Gamma$$ be some surjection. Define a map $$\pi:\Theta^n\to\Gamma^n$$ in the obvious way: $$\pi(y_1,\dots,y_n)=(\phi(y_1),\dots,\phi(y_n))$$. Now define $$Y$$ to be $$\pi^{-1}(X)$$ and regard $$\pi$$ as a map from $$Y$$ to $$X$$.

Let $$A$$ be a winning subset of $$X$$. Then $$\pi^{-1}(A)$$ is easily seen to be a winning subset of $$Y$$ for the same player. For convenience I'll look at the case where $$A$$ is """I-winning""". Let Player I's strategy for $$A$$ be $$\sigma$$. If the play of the game so far has consisted of the specifications $$y_i=\theta_i$$ for each $$i$$ in some set $$K$$ and it is Player I's turn, then she can continue as follows. She works out how $$\sigma$$ responds to the specifications $$x_i=\phi(\theta_i)$$ $$(i\in K)$$. If the answer is a specification $$x_j=\gamma_j$$, then she picks an arbitrary $$\theta_j$$ such that $$\phi(\theta_j)=\gamma_j$$ and plays the specification $$y_j=\theta_j$$.

One can modify this example by picking not the entirety of $$\pi^{-1}(X)$$ but a sufficiently large random (or pseudorandom) subset of $$\pi^{-1}(X)$$. All we need in order for the proof to work is that for any set of specifications $$y_i=\theta_i$$ ($$i\in K$$) and any specification $$x_j=\gamma_j$$ that is consistent with the specifications $$x_i=\phi(\theta_i)$$ ($$i\in K$$), there exists a specification $$y_j=\theta_j$$ that is consistent with the specifications of the $$y_i$$ such that $$\phi(\theta_j)=\gamma_j$$. In other words, we do not need that //every// preimage of $$\gamma_j$$ can be chosen -- just that //at least one// such preimage can be chosen.

Let us define a Ramsey lift to be //trivial// if it has this property. One could describe the property as follows: if you are using a strategy in $$X$$ to play the game in $$Y$$, you don't have to think ahead -- you just lift the specifications from $$X$$ to $$Y$$ greedily and nothing ever goes wrong.

It seems highly plausible that trivial lifts are useless for our purposes, but I have not checked this. So a question that naturally arises is the following (with the expectation that the answer is no): can a lift that is trivial in the above sense be used to simplify a set $$A\subset X$$? [[ClarifyConcept|Can trivial lifts be used to simplify sets?]]

That turns out to be a hardish question. But let's assume that the answer is no and press on.

A thought that came out of the attempt to solve it was that looking at the case $$n=2$$ could be fruitful, since it ought to be considerably easier than general $$n$$, and it might be that even with $$n=2$$ we can prove that a non-trivial Ramsey lift must increase the alphabet size by more than a constant factor. That question looks worth thinking about. [[TryWeakerQuestion|Must all non-trivial Ramsey lifts use large alphabets when n=2?]]

Fortunately, it turns out to be easy to construct non-trivial lifts when $$n=2$$, where by "easy" I mean that the size of the alphabet does not go up very much. In fact, if all one requires is non-triviality, then it is possible to get away with increasing the size of the alphabet by 1.

Given that, the next obvious question is whether we can do something similar for larger $$n$$. I think if we can do $$n=4$$ then we'll probably be able to get general $$n$$. [[TryWeakerQuestion|Must all non-trivial Ramsey lifts use large alphabets when n=4?]]

!!Parent page

We are wondering [[how to get round the natural proofs barrier|How could one conceivably get round the natural proofs barrier?]] So far, we have considered arguments against "simplicity" properties that apply to almost all functions.

!Introduction

The trouble with the title question is that it is too vague. Since this page has no content so far, it seems silly to link to a new page. However, let me draw attention to the operation I now want to perform, in order to transform the question into a more reasonable one. In a way it could be thought of as looking for something more specific, but I think of that as adding conditions in order to narrow down a search. Here I am not exactly //adding// conditions so much as trying to //understand// the conditions that the "strange" simplicity property should satisfy. So I think I'll call this move """MakeConditionsMorePrecise""".

!What exactly do we want of our "strange" property?

We seem to have a very serious difficulty. Let me try to summarize it as clearly as possible.

#We want to define a simplicity property that will distinguish between functions with low circuit complexity and some specified function in NP.
#We want the property to be easier to verify than properties such as "has circuit complexity at most $$m$$".
#However, [[random functions of low circuit complexity|A model of random functions of circuit complexity at most m]] appear to be highly pseudorandom, so a property that is easy to verify and applies to all low-circuit-complexity functions has a very strong risk of applying to almost all functions.
#If almost all functions are simple and $$\Sigma$$ is the class of simple functions, then every Boolean function is a mod-2 sum of two functions in $$\Sigma$$.
#If we try to think instead about a property that measures how close we are to computing the given NP function, then we run into a similar difficulty: if our closeness property is too simple, then it will apply to almost all functions.

!Further thoughts about the natural proofs barrier

As I've presented it so far, the difficulty is that we have a rather wild and random looking set -- the set of all functions of polynomial circuit complexity -- which we want to separate from a singleton set -- the set that contains some given function in NP.

Why is that a difficulty? Well, let us try to imagine what a proof would look like. Our starting assumption is "$$f$$ has circuit complexity at most $$m$$" (where $$m$$ is something like $$n^{\log\log n}$$ -- anyhow, a function that grows superpolynomially), and the statement we aim to prove is "$$f$$ is not the function $$g$$", where $$g$$ is some NP function of our choice. Let's write $$P(f)$$ for the first statement and $$Q(f)$$ for the second.

The way we would normally expect a proof to go is something like this. We find a chain of statements $$P=P_0(f),P_1(f),\dots,P_k(f)=Q(f)$$ for which we can prove that $$P_0\implies P_1\implies\dots\implies P_k$$. Each one of these statements can be identified with a property of functions: $$P_i$$ corresponds to the set of functions $$h$$ such that $$P_i(h)$$ holds. I will freely refer to them as either statements or properties.

Now if, as here, it isn't at all obvious why $$P$$ should imply $$Q$$, then we expect that at least one of the intermediate properties $$P_i$$ should be "genuinely distinct" from both $$P$$ and $$Q$$. For if this is not the case, then for one of the implications $$P_{i-1}\implies P_i$$ we will have that $$P_{i-1}$$ is "essentially the same" as $$P$$ and $$P_i$$ Is "essentially the same" as $$Q$$, which has the undesirable consequence that proving that $$P_{i-1}\implies P_i$$ is "essentially the same" as solving the original problem.

This general situation is not particular to the P versus NP problem: it occurs throughout mathematics. What gives us confidence that an intermediate property $$P_i$$ represents progress towards finding a proof, rather than being a trivial reformulation that leaves us more or less where we started? A common answer is that $$P_i$$ is in some way //simpler// than either $$P$$ or $$Q$$. Of course, since $$P$$ implies $$P_i$$ we are also asking for $$P_i$$ to be a //generalization// of $$P$$.

But this is precisely what the natural proofs barrier makes so hard to achieve. We would like to find some general property $$S$$ and prove that functions of low circuit complexity also have property $$S$$. We would also like that property to be sufficiently simple that we can prove that some NP function does //not// have it. But to be non-trivial, the property mustn't be something like "is not the function $$g$$", so we are also asking for $$\neg S$$ to be a significant generalization of "is not $$g$$". That is, we want to show that the function $$g$$ has some property that causes it not to satisfy $$S$$.

I've been waiting to slip in a nice quote from Timothy Chow, whose response to [[a cs stackexchange question I've already mentioned|http://cstheory.stackexchange.com/questions/170/how-does-the-mulmuley-sohoni-geometric-approach-to-producing-lower-bounds-avoid/4013#4013]] contained the following couple of sentences.

>Razborov–Rudich usually doesn't present much of an obstacle in the early stages of planning a line of attack on circuit lower bounds, as long as you leave some room in your plan for eventually employing "special properties" of your candidate Boolean functions. It's only when you roll up your sleeves and try to fill out the details of the argument that the naturalization barrier will start to rear its head in earnest.

I agree wholeheartedly with this, and the way I interpret it is as follows. When you are starting to plan a proof that avoids the natural-proofs barrier, you tend to think of complicated properties that are implied by low circuit complexity, and small properties that are enjoyed by your target function. But at some point you have to find a path from a property of the first kind to the negation of a property of the second kind, and it is here that you usually find that you have no idea what to do.

!Can we "identify the jump"?

Let us try to be more precise about this difficulty. The property we start with involves an existential quantifier: //there exists// a circuit of size at most $$m$$ that computes $$f$$. The property we are aiming to prove does not involve an existential quantifier: we just want to show that $$f\ne g$$. So somewhere along our chain of implications, we need to drop the existential quantifier. I should add that the existential quantification is over a big set -- there are at least $$2^m$$ circuits of size $$m$$, so if $$m$$ is superpolynomial, then the number of circuits is not even a quasipolynomial function of $$2^n$$. Thus, when viewed as a property of truth tables, the property "has circuit complexity at most $$m$$" is most naturally thought of as an NP property. (Given a circuit, it is very simple to check in time polynomial in $$2^n$$ whether it actually computes a given function $$f$$.)

One might think that a good way of dropping the existential quantifier is simply to say, "Let $$C$$ be a circuit of size at most $$m$$ that computes $$f$$." Now our hypothesis has changed to the much more straightforward "$$C$$ computes $$f$$." Perhaps from that we can hope to deduce that $$f\ne g$$.

However, this is a cheat, and like many cheats it doesn't work. It's tempting to think of $$C$$ as some fixed circuit, but the fact is that //we know absolutely nothing about it//. So we can't deduce anything from the fact that $$C$$ computes $$f$$ that doesn't follow from the more general statement that //there exists// $$C$$ that computes $$f$$. So the apparent shedding of the existential quantifier is an illusion. (Maybe another way of putting that is to say that we can shed the existential quantifier, but we are left with something else -- a completely arbitrary circuit $$C$$ -- that itself needs to be shed somehow.)

Earlier, I gave a kind of "intermediate value theorem" argument for the difficulty of proving that a function has high circuit complexity, which was that if our proof consists of a string of implications, each of which is either close to the statement "has low circuit complexity" or close to the statement "is not $$g$$", then somewhere there must be a jump from one kind of statement to the other. Now I am suggesting a slightly more precise kind of jump: there must be a moment at which we do something that can be thought of as passing from a statement that begins with an existential quantifier to a statement that does not begin with an existential quantifier. ''//Open task: make this argument more precise and rigorous//''.

!Making the jump easier to identify

Suppose we have a proof that some target function $$g$$ in NP does not have polynomial circuit complexity. Then we will also have proved that if $$f$$ is any function of polynomial circuit complexity, then $$f\oplus g$$ does not have polynomial circuit complexity. Thus, it ought to be possible to write our proof in a way that distinguishes between the class of functions of low circuit complexity and the class of functions that differ from $$g$$ by a function of low circuit complexity. That is, by examining our proof, we ought to be able to identify some property $$S$$ such that $$f$$ has property $$S$$ whenever $$f$$ is of polynomial circuit complexity, while $$f\oplus g$$ does not have property $$S$$. ''//"""OpenTask""": make this argument more rigorous too.//''

Thinking of $$S$$ as a set (of all functions with the given property), we are asking that all functions of low circuit complexity should belong to $$S$$, while all functions that differ from $$g$$ by a function of low circuit complexity should belong to $$S^c$$.

For convenience let me write $$K$$ for the set of functions of low circuit complexity. Here are a few things we know about $$K$$.
*$$K$$ looks very much like a random set of functions.
*Therefore, $$g\oplus K$$ also looks very much like a random set of functions.
*$$K$$ has an """NP-ish""" existentially quantified flavour.
*Therefore, $$g\oplus K$$ also has an """NP-ish""" existentially quantified flavour.

I visualize this as follows. Because they both look random, the sets $$K$$ and $$g\oplus K$$ are very heavily intertwined, a bit like a bush that is made of brambles and bindweed. Finding a set that contains one and is disjoint from the other is therefore very hard. The easiest way of doing it is to "shrinkwrap" one of the two sets inside a set that is scarcely any bigger and use that to define a bipartition. That is roughly what happens if we use a property that is """NP-ish""" (and shrinkwraps $$K$$) or """co-NP-ish""" (and shrinkwraps $$g\oplus K$$). But the trouble with shrinkwrapping is that a shrinkwrapped set is just as hard to deal with as the original set.

Returning to the idea of a jump, here we seem to need to jump from a property that is naturally expressed with an existential quantifier (having low circuit complexity) to one that is naturally expressed with a universal quantifier (for every small circuit $$C$$, $$C$$ does not compute $$f\oplus g$$).

!A result of Rudich

The natural proofs argument shows that we cannot separate $$K$$ from $$g\oplus K$$ using a separating property of polynomial (in $$2^n$$) circuit complexity. That is, we cannot find a polynomially computable set $$S$$ such that $$K\subset S$$ and $$S\cap (g\oplus K)=\emptyset$$.

An interesting extension of Rudich shows that in a certain sense we cannot even find an //NP// set $$S$$ that will do the job. Of course, without some qualification that is blatantly false, since K is itself an NP set. However, what Rudich shows is that, subject to some reasonable-looking conjectures, the set $$K$$ (or rather, a set of low-complexity functions that he constructs, but it is reasonable to guess that the same conclusion would hold for $$K$$) is not only pseudorandom for simplicity properties of polynomial circuit complexity but even for simplicity properties that are in """co-NP""". That is, if a simplicity property $$S$$ is in """co-NP""" when considered as a function of truth tables, then $$S$$ will hold for roughly the same proportion of functions in $$K$$ as of all functions. In particular, if it holds for all functions in $$K$$, then it will hold for almost all functions.

By taking complements, we can deduce that any """NP""" property that is disjoint from $$g\oplus K$$ is very small. So in a sense what we learn from this is that if we use an NP property then we must "shrinkwrap" $$K$$, whereas if we use a """co-NP""" property then we must "shrinkwrap" $$g\oplus K$$.

So if we want a "smooth transition" from "belongs to $$K$$" to "does not belong to $$g\oplus K$$" we need to find some way of getting from NP to """co-NP""" without jumping. That seems pretty hard!

!What next?

There is a small crumb of comfort that we can derive from the above argument, which is that it makes the nature of our task clearer. As I see it, it leaves us with one of two options.
#We find a clever way of deducing a universal statement from an existential one.
#We find an intermediate property that does not feel either """NP-ish""" or """co-NP-ish""".

The first option is to admit that there is a jump and just find a way of actually making that jump. The second is to try to find a "continuous path", which will have to go via a property that does not "shrinkwrap" either of the two end properties. It seems to be worth thinking about both possibilities. So that is what I want to do next.

How can one deduce a universal statement from an existential one?  [[TryWeakerQuestion|How can one deduce a universal statement from an existential one?]]

What sort of set could squeeze between a random-looking NP set and a random-looking """co-NP""" set? [[TryWeakerQuestion|What sort of set could squeeze between a random-looking NP set and a random-looking co-NP set?]]

From the second """TryWeakerQuestion""" link above, I feel as though I have narrowed down the question I want to ask. So now I am going to [[LookForSomethingMoreSpecific|Given what I now think, what might a "strange" simplicity property look like?]].
|~ViewToolbar|+editTiddler +cloneTiddler changeToPublic changeToPrivate > fields revisions  permalink closeOthers < closeTiddler|
|~EditToolbar|+saveTiddler saveDraft -cancelTiddler deleteTiddler|
|~RevisionToolbar|> fields revert|
!!Parent page

We are trying to [[find a finitary analogue of Martin's theorem|What might a finitary analogue of Martin's theorem look like?]].

!Introduction

We have had quite a lot of trouble with games, and the underlying difficulty seems to be that games are naturally played on trees, and the "basic open subsets" of the set of paths in a tree don't correspond well to the "basic open subsets" of $$\{0,1\}^n$$.

There are two responses one might make to this. One is to give up on the idea of trying to find a finitary version of Martin's theorem. The other is to try to modify the theorem in such a way that something like Martin's proof still works and the theorem has a finitary version.

!A generalization of games and determinacy

Let's just think informally about the features a proof would need for it to constitute a generalization of Martin's proof of Borel determinacy.
#It should show that if $$A$$ is a subset of low complexity of a set $$X$$ with some kind of structure that generalizes some aspect of the structure of the cube $$\{0,1\}^n$$, then either $$A$$ contains a subset of one kind or $$A^c$$ contains a subset of another kind. (In the case of determinacy the structure is a tree and the subsets we are looking are strategic subtrees. <<slider chkDefineStrategicTree "What is a strategic subtree?" "What are those?" "Definition of strategic trees">>)
#To show this, it should prove inductively that $$X$$ can be lifted to a structure $$X'$$ such that the lift of $$A$$ is so simple that an easy argument shows that the desired Ramsey property is satisfied.
#The fact that the Ramsey property is satisfied by the lift of $$A$$ should imply that it is satisfied by $$A$$.

Now let us try to make some parts of that a little more precise. The aspect of $$\{0,1\}^n$$ that particularly interests us is that it has a collection of "very simple" subsets, out of which all sets of low circuit complexity can be efficiently built using elementary Boolean operations. Those subsets are the coordinate hyperplanes. So any structure $$X$$ to which our result applies should probably have such a collection of subsets.

If $$X'$$ is a lift of $$X$$, then we will want a map $$\pi:X'\to X$$. This map should be "structure preserving" in some useful sense. We will need that useful sense to have the following main consequence.
*If $$A$$ is a subset of $$X$$, then the complexity of $$\pi^{-1}(A)$$ in $$X'$$ is no greater than the complexity of $$A$$ in $$X$$.
That would appear to be the case if and only if the inverse image of every "very simple" subset of $$X$$ is a "very simple" subset of $$X'$$.

We will also need it to be the case that for every $$X$$ and every subset $$A\subset X$$, there is some $$X'$$ and some structure-preserving map $$\pi:X'\to X$$ such that $$\pi^{-1}(A)$$ is simple enough for the Ramsey property to be easy to prove. Loosely speaking, $$\pi^{-1}$$ should never increase complexity and should sometimes decrease it.

If $$\mathcal{F}(X)$$ and $$\mathcal{G}(X)$$ are the classes of subsets of the kind we are looking for in the Ramsey property, then for every $$F'\in\mathcal{F}(X')$$, the projection $$\pi(F')$$ should contain some $$F\in\mathcal{F}(X)$$ and similarly for every $$G'\in\mathcal{G}(X')$$.

!!Proof that low-complexity subsets of X satisfy the Ramsey property

This subsection is a bit of a joke, since I haven't said what anything is. Nevertheless, let me tell the joke. Let $$A$$ be a low-complexity subset of $$X$$. Then we can find a lift $$(X',\pi)$$ of $$X$$ such that $$\pi^{-1}(A)$$ is very simple. Therefore, either $$\pi^{-1}(A)$$ contains a subset $$F'\in\mathcal{F}(X')$$ or $$\pi^{-1}(A^c)$$ contains a subset $$G'\in\mathcal{G}(X')$$. In the first case, $$\pi(\pi^{-1}(A))$$, and hence $$A$$, contains some $$F\in\mathcal{F}(X)$$ and in the second case $$\pi(\pi^{-1}(A^c)$$, and hence $$A^c$$, contains some $$G\in\mathcal{G}(X)$$.

So the aim now is to choose the definitions so as to make the above proof work. That is, we need to decide the following things (if possible, which it may very well not be).
#What is our class of structures, what are the maps between them, and what are the "basic" subsets out of which the low-complexity subsets are built?
#What is the Ramsey theorem we wish to prove?
#What are the "simple" sets for which we have a relatively straightforward (but not trivial) proof of the existence of a lift?

!A cause for anxiety

This is an imprecise thought. If I understand [[Håstad's switching lemma|http://en.wikipedia.org/wiki/Switching_lemma]] correctly, then it follows from that lemma that a set $$A$$ defined by a bounded depth and polynomial size circuit satisfies a Ramsey property: either $$A$$ or $$A^c$$ contains a large affine subspace of the simple form that a few coordinates are fixed and the rest are allowed to vary freely. (That is because if you randomly fix a few coordinates, then with high probability what remains of the function depends on only a few variables. So if you fix those as well then it becomes constant.) Might it be that this result is the natural analogue of Martin's theorem? If so, that would be quite disappointing.

So a key issue is going to be this: can we think of a reason that our simplicity property, whatever it might be, will not blow up when the depth of the circuit that computes $$A$$ blows up?

!How "special" should the Ramsey property be?

One of the challenges at the moment, if there is anything to this idea, is coming up with a suitable Ramsey property. We could try to narrow down the search by answering the following question.

In the (finite) games situation, the Ramsey property, determinacy, applies to //all// sets. Our hope was therefore not to use determinacy as a distinguishing property of sets of low circuit complexity, but to use //the size of the smallest lift// that established determinacy. This didn't work, but it was the aim.

Now that we are trying to generalize the notion of lift to other Ramsey properties, we face this question once again: are we trying to find a Ramsey property that applies to //all// sets, or do we want it to be a special property that applies to sets of low circuit complexity and not to typical sets?

The answer to this question is not quite 100% clear, but I have a strong preference for a property that applies at the very least to random sets, and here's why. To begin with, if it can be decided in polynomial time (in $$2^n$$) whether the Ramsey property holds for a given set $$A$$, then we run up against the natural proofs barrier: if it holds for all sets of low circuit complexity then it will hold for almost all sets (which is another way of saying that it will hold for random sets). So if the Ramsey property is too simple, then we have no choice but for it to hold for almost all sets.

What if the Ramsey property is more complicated? For instance, there might be a very large collection of possible subsets for $$A$$ or $$A^c$$ to contain, and it might be a difficult computational problem to decide whether $$A$$ or $$A^c$$ does contain one of them. But in this case it is still highly likely that the Ramsey property would at least belong to NP. That is, if you were given a set, you could probably check in polynomial time (in $$2^n$$) whether it is a subset of $$A$$ (that part is easy of course) and whether it is one of the structures given by the Ramsey property.

Although I don't have a proof that that is a bad idea, I have my worries, which I explored (without coming to any proper conclusion) in a page where I discussed [[whether there were likely to be NP properties that followed "interestingly" from low circuit complexity|What counts as an "interesting" consequence of low circuit complexity?]]. If the answer is no, then we are going to have trouble finding a non-trivial Ramsey property. (An example of a trivial Ramsey property is "either $$A$$ or $$A^c$$ has a subset of circuit complexity at most $$m$$".)

Now that I've written the last few paragraphs, I find myself not completely convinced by them. It doesn't seem impossible that there might be a Ramsey property that is hard to verify (and so belongs to NP rather than P), that holds for sets of low circuit complexity, and that does not hold for random sets. So I think I'll keep an open mind about this aspect.

!How much structure is needed for complexity to make sense?

Given a lift $$(X,\pi)$$ of $$\{0,1\}^n$$, we need to be able to say things like that a set $$\pi^{-1}(A)$$ has complexity no greater than that of $$A$$. So we need to be able to talk about the complexity of subsets of $$X$$.

It seems to me that we need hardly any structure to do this. If $$\pi:X\to\{0,1\}^n$$ and $$E_k$$ is a coordinate hyperplane in $$\{0,1\}^n$$, then we need $$\pi^{-1}(E_k)$$ to be a "basic" subset of $$X$$. And once we have our basic subsets of $$X$$, we can simply define the complexity of an arbitrary subset of $$X$$ to be the length of the shortest straight-line computation of that subset in terms of basic sets.

Note that every set that can be produced from the sets $$\pi^{-1}(E_k)$$ using Boolean operations is the inverse image of some subset of $$\{0,1\}^n$$. Therefore, if the map from $$X$$ to $$\{0,1\}^n$$ is not an injection and the only basic sets in $$X$$ are the sets $$\pi^{-1}(E_k)$$, then not every subset of $$X$$ will have finite circuit complexity. But if this is a problem, we have the option of enlarging the stock of basic sets in $$X$$.

Bearing these considerations in mind, I would like to propose the following as a definition of a "structure" that generalizes $$\{0,1\}^n$$. I emphasize that this is just a preliminary definition, since we will almost certainly need to add further structure in order to be able to describe a class of sets that will be used for a Ramsey property. Also, I am making a choice here that I might conceivably want to revise.

''Definition.'' A //complexity structure// is a subset $$X$$ of a set $$\Gamma^n$$. Given such a structure, the //basic sets// are all sets of the form $$\{x\in X:x_i\in\Delta\}$$ for some $$1\leq i\leq n$$ and some subset $$\Delta$$ of $$\Gamma$$.

Thus, I'm taking the basic sets to be all sets you can obtain by specifying where one coordinate can be. This is not too far from defining them to be sets of the form $$B(i,\Delta,X)=\{x\in X:x_i=\gamma\}$$ but I prefer the formulation above, since that way it makes it easier for the inverse image of a basic set to be basic. Let me turn to that next.

''Definition.'' A //lift// of a complexity structure $$X$$ is a complexity structure $$X'$$ and a map $$\pi:X'\to X$$ such that for every $$x',y'\in X'$$ and every $$1\leq i\leq n$$, if $$x_i'=y_i'$$ then $$\pi(x')_i=\pi(y')_i$$.

The condition here is saying that the $$i$$th coordinate of $$\pi(x')$$ depends only on the $$i$$th coordinate of $$x'$$. Suppose that that condition holds and let $$1\leq i\leq n$$ and $$\Delta\subset\Gamma$$. Let $$\Delta'$$ be the set of all $$\gamma'\in\Gamma'$$ such that if $$x_i'=\gamma'$$ then $$\pi(x_i')\in\Delta$$. Then $$\pi^{-1}(B(i,\Delta,X))=B(i,\Delta',X')$$.

Later, I want to say that a //Ramsey lift// is one that in some sense preserves the Ramsey property we are interested in, in the same sense that Martin's lifts "preserve determinacy". But for now I want to concentrate on something simpler.

!Is it possible to lift a subset of a complexity structure to a subset of much lower complexity of some other complexity structure?

It occurs to me that I haven't adequately ruled out trivial things like making $$X'$$ empty. So to keep things interesting, let me add the condition that the map $$\pi$$ should be a surjection.

If we allow that, then it is easy to lift complex sets to simple ones. For example, consider the following lift of $$\{0,1\}^n$$. We let $$\Gamma=\{0,1\}^n$$ and we take $$X$$ to be the set of all constant sequences in $$\Gamma^n$$. That is, $$X$$ contains sequences of the form $$(x,x,\dots,x)$$, where $$x\in\{0,1\}^n$$. The map $$\pi:X\to\{0,1\}^n$$ then takes $$(x,x,\dots,x)$$ to $$x$$. Note that the $$i$$th coordinate of $$\pi(x,\dots,x)$$ is $$x_i$$, which trivially depends only on the $$i$$th coordinate of $$(x,x,\dots,x)$$.

Now let $$A$$ be an arbitrary subset of $$\{0,1\}^n$$. Then for every $$i$$, $$\pi^{-1}(A)$$ is equal to the basic set $$B(i,A,X)$$ (and in particular these basic sets are all equal to each other). In a sense, what this lift is doing is ripping $$A$$ apart so that the "topology" becomes "discrete" and all sets are basic. Thus, we are making $$A$$ simpler by making the "topology" far finer.

It is clear that to do something interesting we would like to make $$A$$ simpler while //not// making the topology too much richer.

!Why do we need the Ramsey property?

The lift just described seems a bit too trivial. So how can we ensure that it is less trivial? One way is to try to find a lift with a much smaller size of $$\Gamma$$. Then the points of $$X$$ will be forced to "interact" (principally by sharing coordinates) and the lift will automatically become more interesting. Do we need to ask for more than this? Do we need classes $$\mathcal{F}(X)$$ and $$\mathcal{G}(X)$$ of subsets of $$X$$ so that whenever we have a lift $$\pi:Y\to X$$ we also have the property that for every $$F\in\mathcal{F}(Y)$$, $$\pi(F)$$ has a subset in $$\mathcal{F}(X)$$?

It might be worth spending a bit of time thinking about lifts and not worrying about Ramsey properties. However, I would find that rather unlikely to work. I think one of two things is likely to happen. Either we would find that the size smallest alphabet $$\Gamma$$ that can be used to make $$A$$ basic (or close to basic -- it's not clear what the correct target is) will blow up quickly so that the worst case is something like the parity function, or we would find that for some fairly simple reason we can take $$\Gamma$$ to be about the same size as the smallest circuit that computes $$A$$. However, it would certainly be worth checking this.

The other reason I think that would probably be too simple is that if we don't insist that our lifts have a "Ramsey-preserving" property, then the conditions we are putting on them become considerably less complex, which reduces the likelihood that we will get round the natural proofs barrier.

!What next?

It's time to write down a list of questions that look as though they need answering.

If we ignore the Ramsey property, then how small an alphabet do we need in order to lift a set of circuit complexity at most $$m$$ to a set of circuit complexity 1? [[TryWeakerQuestion|How large an alphabet do we need to make a set basic?]]

If we want a Ramsey property, then what features should it have? [[TryToMakeQuestionMorePrecise|If we want a Ramsey property, then what features should it have?]]

If we had a suitable Ramsey property, then what might the eventual proof look like? Is there a convincing answer to this? [[EvaluateApproach|Is there a realistic proposal for how an eventual proof might look?]]

How different is this set-up from the obvious invariant game? [[EvaluateApproach|What is the difference between this set-up and the invariant game?]]
!!Parent page

We are wondering [[whether there is an analogue of Martin's theorem concerning more general Ramsey properties|Can we find an analogue of Martin's theorem by thinking about more general Ramsey properties?]].

!Introduction

We are wondering what will happen if we try to deal with the various drawbacks associated with trees (explored [[here|Can we find an analogue of Martin's theorem using the obvious game?]] and [[here|Can we find an analogue of Martin's theorem using the obvious invariant game?]]) by looking at complexity structures instead. <<slider chkWhatIsComplexityStructure "What is a complexity structure?" "What are those?" "Reminder of definition">>

But at first glance it may appear as though treating the set $$\{0,1\}^n$$ as a set with certain basic subsets is dealing with the asymmetry associated with the obvious game in a way that is not all that different from how we tried to deal with it by introducing the obvious invariant game. Is there in fact a significant difference?

!Expressing everything in terms of neighbourhoods

I think the way to see the difference is as follows. A finite tree $$T$$ comes with a set $$[T]$$ of leaves, and the other vertices can be thought of as "neighbourhoods" in $$[T]$$: the neighbourhood associated with a vertex $$v$$ is the set of leaves that are descended from $$v$$.

A natural way of labelling the leaves of the tree $$T$$ on which the invariant game is played is, as we have seen in [[the page on that game|Can we find an analogue of Martin's theorem using the obvious invariant game?]], to attach an ordered pair $$(x,\theta)$$, where $$x\in\{0,1\}$$ and $$\theta$$ is a permutation of $$\{1,2,\dots,n\}$$. We think of this as telling us the final sequence in the game and the order in which its bits are specified. A neighbourhood in $$[T]$$ can be thought of as a specification of $$k$$ of the bits in some order, or rather as the set of all leaves consistent with both that specification and that ordering. For example we could take the set of bit specifications that begins $$x_3=0, x_{275}=1, x_2=1$$.

The difficulty we had was that a subset corresponding to a coordinate hyperplane such as $$x_1=1$$ cannot be described efficiently in terms of big crude neighbourhoods. That is because there are several leaves where the specification that $$x_1=1$$ comes right at the end of the sequence. So the set of leaves with $$x_1=1$$ is in some sense topologically complicated when it should be topologically very simple.

If we treat $$\{0,1\}^n$$ as a complexity structure, then we do not have this problem. We define the basic sets to be precisely the coordinate hyperplanes -- the very sets that we want to be simple to describe. So we are doing the obvious thing. And we have a very obvious set of neighbourhoods, namely intersections of these basic sets. And there is no duplication of leaves.

!Is that the whole story?

What if we take the tree corresponding to bit specifications as above //and identify leaves// if they end up giving the same sequence? That is, we identify the leaves $$(x_1,\theta_1)$$ and $$(x_2,\theta_2)$$ if and only if $$x_1=x_2$$. If we now define a neighbourhood to be the set of leaves that are descendants of a vertex in the tree, what does a neighbourhood look like?

A typical vertex looks like a partial specification $$x_{i_1}=\epsilon_1,\dots,x_{i_k}=\epsilon_k$$, and the set of leaf descendants of that vertex is simply the set of all sequences $$x\in\{0,1\}^n$$ that satisfy those $$k$$ specifications. And that is precisely what we want the neighbourhoods to be.

Of course, once we've done that, it becomes natural to identify two specifications if they are equal up to a permutation, and we find that we might as well not bother with the tree and just talk about the neighbourhoods.

!Conclusion

The obvious invariant game came close to giving us what we wanted, but we were too wedded to the idea of trees. Once we accept more general """DAGs""" (=directed acyclic graphs), we obtain what we want.

This gives me an idea. Could we use the DAG to define half-dimensional sets? Where to put this question on the proof-discovery tree is a little tricky: it is clearly inspired by this page, but it probably belongs as a child of the page [[What is the right definition of a "half-dimensional set"?]]. I don't want to be too wedded to trees, so I'll make it a child of both pages. [[LookForSomethingMoreSpecific|Can we use a DAG picture to define half-dimensional sets?]]

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
Writing up proof attempts in a structured way
!!Parent page

We are [[looking for a useful definition of simplicity|Is there a useful definition of simplicity?]]. We have given up on the idea of using a numerical measure of complexity/simplicity for obtaining interesting lower bounds for circuit complexity.

!Introduction

Recall that by a set-valued complexity measure I mean a function $$\mu$$ that takes subsets of $$\{0,1\}^n$$ to subsets of some other set $$X$$ and has the following properties.

*$$\mu(E_i)$$ is a small set for every $$i$$.
*$$\mu(U\cap V)\setminus(\mu(U)\cup\mu(V))$$ is a small set for every $$U$$ and $$V$$.
*$$\mu(U\cup V)\setminus(\mu(U)\cup\mu(V))$$ is a small set for every $$U$$ and $$V$$.
*$$\mu(U^c)\setminus\mu(U)$$ is a small set for every $$U$$.
*$$\mu(A)$$ is large for some NP set $$A$$.

At this stage, it is not clear what "is a small set" and "is large" should mean, but an obvious idea is to interpret them as bounds on cardinality. It is a straightforward exercise to prove that if $$\mu$$ is a set-valued complexity measure and $$A_1,A_2,\dots,A_m$$ is a straight-line computation of a set $$A$$, then $$\mu(A)\subset\bigcup_i\mu(A_i)$$. [[MoreDetails|A simple lemma about set-valued complexity measures]]
!!Parent page

We are trying to determine [[whether trivial lifts can simplify sets|Can trivial lifts be used to simplify sets?]].

!Introduction

Let $$X$$ be a complexity structure and let $$\pi:Y\to X$$ be a trivial lift. Suppose that $$A\subset X$$ is not a basic set. Can $$\pi^{-1}(A)$$ be a basic subset of $$Y$$?

!Proof attempt

Let's just dive in, try to prove it in an obvious way, and see whether we get stuck. Suppose that $$X\subset\Gamma^n$$, $$Y\subset\Theta^n$$, and $$\pi^{-1}(A)=\{y\in Y:y_i\in\Delta_i\}$$. Suppose also that $$\phi:\Theta\to\Gamma$$ is such that $$\pi(y_1,\dots,y_n)=(\phi(y_1),\dots,\phi(y_n))$$ for every $$y\in Y$$.

If $$A$$ is going to be a basic set, then we can write down what that set is likely to be. It will probably be $$\{x\in X:x_i\in\phi(\Delta_i)\}$$. I'm pretty sure this set is simply $$\pi(\pi^{-1}(A))$$.

''Check claim''

If $$x_i\in\phi(\Delta_i)$$, then the triviality condition with $$K=\emptyset$$ allows us to find $$\theta\in\Theta$$ such that $$\phi(\theta)=x_i$$ and such that there exists $$y\in Y$$ with $$y_i=\theta$$. If we now apply the triviality condition over and over again, we can extend the specification $$y_i=\theta$$ to a complete set of specifications of some $$y$$ such that $$y_i=\theta$$ and $$\pi(y)=x$$.

''Difficulty''

There seems to be no reason to suppose that $$\theta\in\Delta_i$$.

''Forget claim and try to prove result without it''

I'm not sure I actually needed the claim -- it was just an observation I thought it was possible to make. So let's go back to what we were trying to show. We wanted to show that $$A=\{x\in X:x_i\in\phi(\Delta_i)\}$$. Is that true?

''Check claim we actually need''

We are trying to show that if $$\pi^{-1}(A)=\{y\in Y:y_i\in\Delta_i\}$$, then $$A=\{x\in X:x_i\in\phi(\Delta_i)\}$$.

Suppose first that $$x\in A$$. Can we show that $$x_i\in\phi(\Delta_i)$$? What we can definitely do is find $$y\in Y$$ such that $$\phi(y_i)=x_i$$. This follows from the triviality condition with $$K=\emptyset$$. As noted in the failed attempt to prove the earlier claim, we can then apply the triviality condition for the other coordinates to build up a $$y\in Y$$ such that $$\phi(y_i)=x_i$$ and $$\pi(y)=x$$. This $$y$$ belongs to $$\pi^{-1}(A)$$, and therefore satisfies $$y_i\in\Delta_i$$, from which it follows that $$x_i\in\phi(\Delta_i)$$. So we have shown that $$A\subset\{x\in X:x_i\in\phi(\Delta_i)\}$$.

Now suppose that $$x_i\in\phi(\Delta_i)$$. Does it follow that $$x\in A$$? Again, let's find a $$y$$ such that $$\phi(y_i)=x_i$$ and $$\pi(y)=x$$. We seem to have run up against the same difficulty: if at this point we knew that $$y_i\in\Delta_i$$, then we would have $$y\in\pi^{-1}(A)$$ and therefore $$x=\pi(y)\in A$$. However, it does not seem to be obvious that we can ensure that $$y_i\in\Delta_i$$.

''Is this a real difficulty?''

If $$x_i\in\phi(\Delta_i)$$ then there exists $$\theta\in\Delta_i$$ such that $$\phi(\theta)=x_i$$. Must there necessarily be some $$y\in Y$$ such that $$y_i=\theta$$? If there is, then we can extend the specification $$y_i=\theta$$ to the specification of some $$y$$ such that $$\pi(y)=x$$ and we will be done.

It does not seem obvious that there should exist such a $$y$$, but if there doesn't, then we appear to have a simple option: to remove $$\theta$$ from $$\Delta_i$$. Indeed, if there is no $$y\in Y$$ such that $$y_i=\theta$$, then $$\{y\in Y:y_i\in\Delta_i\}=\{y\in Y:y_i\in\Delta_i\setminus\{\theta\}\}$$.

''Complete proof by adding in minimality assumption that we are free to make''

So let us choose $$\Delta_i$$ to be minimal such that $$\pi^{-1}(A)=\{y\in Y:y_i\in\Delta_i\}$$. Then the inclusion that we had trouble proving can now be proved as follows.

Suppose that $$x_i\in\phi(\Delta_i)$$. Let $$\theta\in\Delta_i$$ be such that $$\phi(\theta)=x_i$$. By the minimality of $$\Delta_i$$ there exists $$y\in Y$$ such that $$y_i=\theta$$. Using the triviality condition, we may find $$y\in Y$$ such that $$y_i=\theta$$ and $$\pi(y)=x$$. Since $$y_i\in\Delta_i$$, we have $$y\in\pi^{-1}(A)$$ and therefore $$x=\pi(y)\in A$$.

Note that if we add the minimality condition, then we obtain the claim we tried and failed to prove above as well.

!Conclusion

If the above argument is correct, then trivial maps cannot be used to lift non-basic sets to basic sets. Indeed, we can say slightly more. If $$\pi:Y\to X$$ is a trivial map and $$A\subset X$$ is a set such that $$\pi^{-1}(A)$$ is a basic subset of $$Y$$ defined by restricting the $$i$$th coordinate, then $$A$$ is a basic subset of $$X$$ defined by restricting the $$i$$th coordinate.

/***
|''Name''|HistoryPlugin|
|''Version''|0.3.5|
|''Author''|Jon Robson|
|''Description''|Auto generates permaviews as you open and close tiddlers. Back button allows you to flick back to previous stories on modern browsers.|
***/
//{{{
(function($) { var lastPermaviewTimeout; function makePermaview() { if(lastPermaviewTimeout) { window.clearTimeout(lastPermaviewTimeout); } lastPermaviewTimeout = window.setTimeout(function() { story.permaView(); }, 200); } var runParamifier = false; var _invokeParamifier = invokeParamifier; invokeParamifier = function() { runParamifier = true; var res = _invokeParamifier.apply(this, arguments); runParamifier = false; return res; } var runPermaview; var _permaview = Story.prototype.permaView; Story.prototype.permaView = function() { runPermaview = true; var res = _permaview.apply(this, arguments); return res; } var _closeAll = Story.prototype.closeAllTiddlers; var closeAll; Story.prototype.closeAllTiddlers = function() { closeAll = true; var res = _closeAll.apply(this, arguments); makePermaview();; return res; }; var _close = Story.prototype.closeTiddler; Story.prototype.closeTiddler = function(title,animate,unused) { var tidEl = story.getTiddler(title); if(tidEl) { tidEl.setAttribute("tiddler", ""); } var res = _close.apply(this, arguments); if(!closeAll) { makePermaview();; } return res; }; var runDisplayTiddlers; var _displayTiddlers = Story.prototype.displayTiddlers; Story.prototype.displayTiddlers = function() { runDisplayTiddlers = true; var el = _displayTiddlers.apply(this, arguments); runDisplayTiddlers = false; makePermaview();; return el; }; var _display = Story.prototype.displayTiddler; Story.prototype.displayTiddler = function(srcElement,tiddler,template,animate,unused,customFields,toggle,animationSrc) { var el = _display.apply(this, arguments); if(!runDisplayTiddlers) { makePermaview();; // to do: dont create permaview for sucked in tiddlers ? } return el; }; var timeout; var hashchange = function(ev) { if(!runPermaview && !runParamifier) { closeAll = true; var p = getParameters(); story.closeAllTiddlers(); // TODO: don't close 'sucked in tiddlers' if(p) { invokeParamifier(p.parseParams("open",null,false), "onstart"); } } if(timeout) { window.clearTimeout(timeout); } if(runPermaview || runParamifier || closeAll) { timeout = window.setTimeout(function() { runPermaview = false; runParamifier = false; closeAll = false; }, 300); } }; window.onhashchange = hashchange; })(jQuery); //}}}  !!Parent page We are trying to decide [[how easy it is to lift a 2-basic set to a 1-basic set|How easy is it to lift a 2-basic set to a 1-basic set?]]. !Introduction Let's try to look at our problem in the abstract. Let $$X$$ be a complexity structure, and let $$A=\{x\in X:x_i\in\Delta_i\}$$ and $$B=\{x\in X:x_j\in\Delta_j\}$$. I'm also assuming that $$i$$ is in the first half of $$\{1,2,\dots,n\}$$ and that $$j$$ is in the second half. The game is that the players take turns specifying coordinates, with all Player I's specifications in the first half and all Player II's specifications in the second half. I want to consider the possibility of finding Ramsey lifts of the following special form. Let's say that $$X\subset\Gamma_1\times\dots\times\Gamma_n$$. Then I want $$Y\subset\Gamma_1'\times\dots\times Gamma_n'$$, where $$\Gamma_i'=\Gamma_i\times U$$, $$Gamma_j'=\Gamma_j\times V$$, and $$\Gamma_r'=\Gamma_r$$ for all other $$r$$. I think of the sets $$U$$ and $$V$$ as providing "extra information". Finally, $$\pi:Y\to X$$ is the obvious map: it just forgets the extra information. (So one condition we place on $$Y$$ is that it is a subset of $$\pi^{-1}(X)$$.) !Does there exist a Ramsey lift with extra information applied just to two coordinates? The trivial lift applied extra information to all coordinates, so the answer to this question is far from clear. Let us try to describe the conditions on $$Y$$ that would be necessary. To that end, let $$\sigma$$ be a """Player I""" strategy for the shrinking-neighbourhoods game on $$Y$$. We would like to define a winning strategy on $$X$$ for producing sequences that are images of runs of $$\sigma$$. As ever, it makes sense for Player I to follow $$\sigma$$ while that is a straightforward thing to do, which it is until the first point that a player specifies coordinate $$i$$ or $$j$$. I'll consider these two cases separately. ''Case 1. Player I specifies the $$i$$th coordinate.'' That means that $$\sigma$$ tells Player I to play a move of the form $$y_i=(\gamma_i,u)$$, where $$\gamma_i\in\Gamma_i$$ and $$u\in U$$. This is unproblematic: Player I can play the move $$x_i=\gamma_i$$ and continue with whatever $$\sigma$$ dictates. Oh wait, is it really that simple? Let us write $$Y(u)$$ for the set of sequences $$y\in Y$$ such that the second coordinate of $$y_i$$ (which is an ordered pair) is $$u$$. It is not necessarily the case that $$\pi(Y(u))=X$$, so if Player II decides not to cooperate, then the game may reach a point where $$\sigma$$ does not dictate anything. I think this may be an important mathematical point that I've missed earlier. OK, given that Player I can't just assume that Player II will cooperate, can we argue that having extra information at just two coordinates is too simple? I think one moral we can draw from it is that the extra information that Player I provides should not take the form of a promise that can be kept only if Player II cooperates. Can we make that moral precise? !An attempt to make precise the informal observation just made Let $$\sigma$$ be a $$Y$$ strategy for Player I that begins with the move $$y_i=(\gamma_i,u)$$. Then the rest of the game takes place in the set $$Y(u)$$. One thing we can say for certain is that if Player II has a winning strategy in $$X$$ for $$\pi(Y(u))^c$$, then we do not have a Ramsey lift. But I feel as though it ought to be possible to say more. For //every// Player I strategy $$\sigma$$ that starts with the move $$y_i=(\gamma_i,u)$$, it must not be possible for Player II to play against the image of that strategy in $$X$$ and obtain a sequence in $$\pi(Y(u))^c$$. !Conclusion I'm getting bogged down. I think it's time to bring in Martin's proof. [[Return to parent page|How easy is it to lift a 2-basic set to a 1-basic set?]] //Added later: while thinking about something else, I came up with a reason for its being unlikely to be possible to lift 2-basic sets to 1-basic sets efficiently. See the end of the parent page for details.// /*** |''Name''|TiddlySpaceRevisionView| |''Description''|Show tiddler revisions in a stack of cards view| |''Author''|BenGillies| |''Version''|0.2.0| |''Status''|beta| |''Source''|http://github.com/TiddlySpace/tiddlyspace| |''CodeRepository''|http://github.com/TiddlySpace/tiddlyspace| |''License''|[[BSD|http://www.opensource.org/licenses/bsd-license.php]]| |''CoreVersion''|2.6.0| |''Requires''|TiddlyWebAdaptor| !Usage The viewRevisions macro can be attached to any element, which should be passed in as a parameter. For example: <<viewRevisions page:10 link:"<<view modified date>>">> would show the revisions "stack of cards" view, 10 at a time, when the modified date is clicked. !Code ***/ //{{{ (function($) {

var me = config.macros.viewRevisions = {
revisionTemplate: "RevisionTemplate",
revSuffix: " [rev. #%0]", // text to append to each tiddler title
defaultPageSize: 5, // default number of revisions to show
defaultLinkText: "View Revisions", // when there's nothing else to use
offsetTop: 30, // in px
offsetLeft: 10, // in px
shiftDownDelay: 50, // in ms
visibleSlideAmount: 20, // amount of revisions to show on left hand edge after sliding
zIndex: 100, // default z-index
handler: function(place, macroName, params, wikifier, paramString, tiddler) {
params = paramString.parseParams(null, null, true)[0];
var tiddlerElem = story.findContainingTiddler(place);

var revButton;
var pageSize = parseInt(params.page[0], 10) || me.defaultPageSize;
revButton = $('') .appendTo(place); wikify(linkObj, revButton[0], null, tiddler); } else { revButton = place; }$(revButton).click(function() {
if (!$(tiddlerElem).hasClass("revisions")) { me.showRevisions(tiddlerElem, tiddler, pageSize); } else { me.closeRevisions(tiddlerElem); } }); }, // initialisation for revision view showRevisions: function(tiddlerElem, tiddler, pageSize) { var context = { host: tiddler.fields["server.host"], workspace: tiddler.fields["server.workspace"] };$(tiddlerElem).addClass("revisions").attr("revName", tiddler.title);
// ensure toolbar commands deactivate RevisionsView
$("a", ".toolbar", tiddlerElem).each(function(index, btn) { var _onclick = btn.onclick; btn.onclick = function(e) { me.closeRevisions(tiddlerElem); _onclick.apply(this, arguments); }; }); // ensure default action deactivates RevisionsView var _ondblclick = tiddlerElem.ondblclick; tiddlerElem.ondblclick = function(e) { me.closeRevisions(tiddlerElem); _ondblclick.apply(this, arguments); }; var type = tiddler.fields["server.type"]; var adaptor = new config.adaptors[type](); var userParams = { tiddlerElem: tiddlerElem, pageSize: pageSize, title: tiddler.title }; me.createCloak(tiddlerElem); adaptor.getTiddlerRevisionList(tiddler.title, null, context, userParams, function(context, userParams) { // strip the current revision context.revisions.shift(); me.expandStack(context, userParams); }); }, // fetch the actual revision and put it in the tiddler div showRevision: function(place, revision, callback) { var context = { host: revision.fields["server.host"], workspace: revision.fields["server.workspace"] }; var userParams = { revElem: place }; var type = revision.fields["server.type"]; var adaptor = new config.adaptors[type](); var revNo = revision.fields["server.page.revision"]; adaptor.getTiddlerRevision(revision.title, revNo, context, userParams, function(context, userParams) { var tiddler = context.tiddler; tiddler.title += me.revSuffix .format([$(place).attr("revision")]);
tiddler.fields.doNotSave = true;
if (store.getTiddler(tiddler.title)) {
store.deleteTiddler(tiddler.title);
}

//now, populate the existing div
var revElem = userParams.revElem;
$(revElem).attr("id", story.tiddlerId(tiddler.title));$(revElem).attr("refresh", "tiddler");
var getTemplate = function() {
var themeName = config.options.txtTheme;
if (themeName) {
return store.getTiddlerSlice(themeName,
me.revisionTemplate) || me.revisionTemplate ||
"ViewTemplate";
} else {
return (store.getTiddler(me.revisionTemplate)) ?
me.revisionTemplate : "ViewTemplate";
}
};
var template = getTemplate();
story.refreshTiddler(tiddler.title, template, true);
callback(tiddler);
});
},

createCloak: function(promoteElem) {
var el = $(promoteElem); // cache styles for resetting later el.data({ top: el.css("top"), left: el.css("left"), zIndex: el.css("z-index") });$('
').css("z-index", me.zIndex)
.click(function() {
me.closeRevisions(promoteElem);
})
.appendTo(document.body);

el.css("z-index", me.zIndex + 1);
},

// clean up, removing all evidence of revision view
closeRevisions: function(promoteElem) {
var el = $(promoteElem); // revert the original tiddler back to its previous state el.removeAttr("revName").removeClass("revisions").css({ top: el.data("top"), left: el.data("left"), zIndex: el.data("zIndex") }); // remove any revisions still in the store var revisions =$(".revisions");
revisions.each(function(index, revision) {
var revAttributes = revision.attributes;
if ((revAttributes.revname) &&
(revAttributes.revision)) {
var revName = revAttributes.revname.value;
var revNo = revAttributes.revision.value;
var title = revName + me.revSuffix.format([revNo]);

if (store.getTiddler(title)) {
store.deleteTiddler(title);
}
}
});

// delete the previous revisions
revisions.remove();

// remove the cloak
$(".revisionCloak").remove(); }, // calback from getting list of revisions expandStack: function(context, userParams) { var pageSize = userParams.pageSize; var from = userParams.from || 0; var tiddlerElem = userParams.tiddlerElem; userParams.defaultHeight =$(tiddlerElem).height();
userParams.defaultWidth = $(tiddlerElem).width(); if (from < context.revisions.length) { me.displayNextRevision(tiddlerElem, userParams, context, from, from + pageSize - 1); } }, // place the next div above and behind the previous one displayNextRevision: function(tiddlerElem, userParams, context, from, to) { var revision = context.revisions[from]; var callback = function() { var revText = revBtn.getRevisionText(tiddlerElem, revision); tiddlerElem = me.createRevisionObject(tiddlerElem, context, userParams, revText);$(tiddlerElem)
.attr("revision", (context.revisions.length - from));
if ((from < to) && ((from + 1) < context.revisions.length)){
me.displayNextRevision(tiddlerElem, userParams, context,
from + 1, to);
} else if ((context.revisions.length - 1) > to) {
me.showMoreButton(tiddlerElem, context, userParams, to + 1);
}
};
me.shiftVisibleDown(userParams.title, callback);
},

createRevisionObject: function(tiddlerElem, context, userParams, text) {
var newPosition = me.calculatePosition(tiddlerElem, context);
return $('
') .css({ position: "absolute", top: newPosition.top, left: newPosition.left, "z-index": me.zIndex + 1, height: userParams.defaultHeight, width: userParams.defaultWidth }) .attr("revName", userParams.title) .append(text) .insertBefore(tiddlerElem); }, // move the already present revisions down by 1 to fit the next one in shiftVisibleDown: function(title, callback) { var revisions =$("[revName='%0'].revisions".format([title]));
var revisionCount = revisions.length;

$(revisions).animate({top: "+=" + me.offsetTop}, me.shiftDownDelay, function() { revisionCount -= 1; if ((callback) && (!revisionCount)) { callback(); } }); }, // where we put the new revision calculatePosition: function(elem, context) { var offset =$(elem).offset();
var currentPosition = $(elem).position(); var newPosition = { top: currentPosition.top - me.offsetTop }; if ((context.restrictLeft) || ((offset.left - me.offsetLeft) <$("#contentWrapper").offset().left)) {
newPosition.left = $(elem).position().left; context.restrictLeft = true; } else { newPosition.left = currentPosition.left - me.offsetLeft; } return newPosition; }, // equivalent of displayNextRevision, but for the more button showMoreButton: function(tiddlerElem, context, userParams, moreIndex) { userParams.from = moreIndex + 1; me.shiftVisibleDown(userParams.title, function() { var btn = me.createRevisionObject(tiddlerElem, context, userParams, ""); var more = createTiddlyButton(btn[0], "more...", "show more revisions", function() { if ($(".viewRevision").length) {
return;
}
userParams.tiddlerElem = btn[0];
$(btn).text("") .append(revBtn .getRevisionText(btn[0], context.revisions[moreIndex])) .attr("revision", context.revisions.length - moreIndex); me.expandStack(context, userParams); });$(more).css("float", "right");
});
},

stripRevFromTitle: function(revisionTitle) {
return revisionTitle.split(/ ?$rev\. #[0-9]+$$/)[0]; }, onClickRevision: function(revElem, revision, callback) { // don't do anything if we are still loading if ($(".revisions").hasClass("loading")) {
return null;
}

var origTitle = me.stripRevFromTitle(revision.title);
if ($(revElem).hasClass("viewRevision")) {$(".revisions").addClass("loading");
me.slideIn(revElem, revision, origTitle, function() {
store.deleteTiddler(revision.title);
revision.title = origTitle;
$(revElem).text("").append(revBtn.getRevisionText(revElem, revision)) .removeAttr("tags").removeAttr("tiddler") .removeAttr("refresh").removeAttr("template") .removeAttr("id");$(".revisions").removeClass("loading");
if (callback) {
callback();
}
});
$(revElem).removeAttr("prevPos").removeClass("viewRevision"); } else { var viewRevision = function() { var prevPos =$(revElem).position().left;
$(revElem).addClass("viewRevision").attr("prevPos", prevPos);$(".revisions").addClass("loading");
me.showRevision(revElem, revision, function(rev) {
me.slideOut(revElem, rev, origTitle, function() {
$(".revisions").removeClass("loading"); }); }); }; // make sure another revision isn't already out if ($(".viewRevision").length) {
var newRevElem = $(".viewRevision")[0]; var newRevision = store.getTiddler($(newRevElem)
.attr("tiddler"));
me.onClickRevision(newRevElem, newRevision, viewRevision);
} else {
viewRevision();
}
}
},

slideOut: function(revElem, revision, title, callback) {
var leftMostPos = $("[revName='%0'].revisions".format([title])) .offset().left; var width =$(revElem).width();
var originalLeftPos = $(story.getTiddler(title)) .position().left; var slideAmount = leftMostPos + width - me.visibleSlideAmount;$("[revName='%0'].revisions:not(.viewRevision)".format([title]))
.animate({left: "-=" + slideAmount}, 1000);
$(revElem) .attr("baseHeight",$(revElem).css("height"))
.css("height", "auto")
.animate({left: originalLeftPos}, 1000, callback);
},

slideIn: function(revElem, revision, title, callback) {
var slideAmount = $(revElem).offset().left -$(story.getTiddler(title)).offset().left;
var origRevPos = $(revElem).attr("prevPos");$("[revName='%0'].revisions:not(.viewRevision)".format([title]))
.animate({left: "+=" + slideAmount}, 1000);
$(revElem).animate({left: origRevPos}, 1000, function() {$(revElem)
.css("height", $(revElem).attr("baseHeight")) .removeAttr("baseHeight"); callback(); }); } }; var revBtn; config.macros.slideRevision = revBtn = { btnText: "created by %0 at %1 on %2", handler: function(place, macroName, params, wikifier, paramString, tiddler) { var btn = revBtn.getRevisionText(place, tiddler);$(place).append(btn);
},

getRevisionText: function(place, revision) {
var text = revBtn.btnText.format([revision.modifier,
revision.modified.formatString("0hh:0mm"),
revision.modified.formatString("0DD MMM YYYY")]);
var btn = $('') .text(text) .click(function() { var revElem = story.findContainingTiddler(this); me.onClickRevision(revElem, revision); }); return btn; } }; })(jQuery); //}}}  In any game, if $$\sigma$$ is a strategy for Player I and $$\tau$$ is a strategy for Player II, then $$\sigma\circ\tau$$ represents the element that is chosen if Player I plays according to $$\sigma$$ and Player II plays according to $$\tau$$.  [[StyleSheetTiddlySpace]] !!Parent page We have been trying to [[find the right definition of a half-dimensional set|What is the right definition of a "half-dimensional set"?]]. !Introduction Assuming that the definition of half-dimensional sets is roughly what we want it to be, it there at least //some// way of Ramsey lifting an arbitrary set? !An idea for a general approach We could first try lifting to a subset of a tree, and if that works then we could hope that the universal lift for games works. What do I mean by that? Well, let $$A$$ be a subset of $$\{0,1\}^n$$. Let $$T$$ be a binary tree with $$n$$ levels, and label the vertices at level $$r$$ by 01 sequences of length $$r$$ in such a way that the successors of $$x$$ are $$x0$$ and $$x1$$. We regard the set of leaves of $$T$$ as a complexity structure by associating each leaf with the path that goes from the root to that leaf. If we write $$\Gamma_r$$ for the set of 01 sequences of length $$r$$, then we are letting our complexity structure $$X\subset\Gamma_1\times\dots\times\Gamma_n$$ be the set of all sequences $$(u_1,u_2,\dots,u_n)$$ such that $$u_i\in\Gamma_i$$ and $$u_i$$ is an initial segment of $$u_{i+1}$$. The map $$\pi:X\to\{0,1\}^n$$ takes $$(u_1,\dots,u_n)$$ to $$u_n$$. Note that this satisfies the required condition: that the $$i$$th coordinate of $$\pi(u)$$ depends only on the $$i$$th coordinate of $$u$$. Does $$\pi$$ take half-dimensional sets to half-dimensional sets? To answer that we need to know what a half-dimensional set is. However, let's be optimistic and assume that strategic subtrees are half dimensional and more or less conversely. What does the image of a strategic subtree look like? I'm a little stuck here because my conception of what a half-dimensional subset of a general structure is is too hazy. I need something more in focus. [[ClarifyConcept|OK, what is a half-dimensional subset of the discrete cube?]] Another idea is to try to find a lift by imitating the proof that works for trees. [[LookForSomethingMoreSpecific|Can we lift an arbitrary set in an analogous way to the way we do it for trees?]] !!Parent page We are wondering [[whether there is a useful numerical measure of simplicity|Is there a useful numerical measure of simplicity?]]. Because the notion of "numerical measure of simplicity" was a little vague, we have replaced it by the more specific notion of a formal complexity measure. !Introduction We would like to find a useful function $$\mu$$ that assigns a number to each subset of $$\{0,1\}^n$$ and has the following properties. *$$\mu(E_i)=1$$ for every $$i$$. *$$\mu(U\cap V)\leq\mu(U)+\mu(V)$$ for any two subsets $$U$$ and $$V$$. *$$\mu(U\cup V)\leq\mu(U)+\mu(V)$$ for any two subsets $$U$$ and $$V$$. *$$\mu(U^c)=\mu(U)$$ for every subset $$U$$. *$$\mu(A)$$ is large for some NP set $$A$$. By //useful// we mean that we would like to be able to prove that the last property holds, and we would also like it to imply that there is a function in NP with superpolynomial circuit complexity. There are difficulties with both these aims. !A first problem with using a formal complexity measure to obtain circuit complexity lower bounds. There is an obvious way of defining a formal complexity measure: just take the maximal one. This can be shown quite easily to exist, and it gives us the //formula complexity// of the set (or function) in question. This can be defined in various equivalent ways. A //formula// can be defined inductively as follows. Let $$x_i$$ stand for the function that equals the $$i$$th bit of a sequence $$x\in\{0,1\}^n$$. (The main point of this trivial-seeming definition is that I am regarding $$x_i$$ as a function of $$x$$ rather than just as an element of $$\{0,1\}$$. It is the characteristic function of the set $$E_i$$. I am also regarding it as the //property// that the $$i$$th coordinate is equal to 1. Thus, I am happy to write $$\neg x_i$$ instead of $$1-x_i$$.) Then *every $$x_i$$ is a formula; *if $$\phi$$ is a formula, then so is $$\neg\phi$$; *if $$\phi$$ and $$\psi$$ are formulae, then so is $$\phi\wedge\psi$$; *if $$\phi$$ and $$\psi$$ are formulae, then so is $$\phi\vee\psi$$. An example of a formula is $$((x_1\wedge\neg x_2)\vee(x_1\wedge x_3))\wedge\neg(x_1\vee x_2)$$ The //size// of a formula is the number of variables it contains, with multiplicity. For example, the size of the formula just given is 6. The //formula complexity// of a Boolean function $$f$$ is the size of the smallest formula $$\phi$$ that computes $$f$$. The formula complexity of a set is just the formula complexity of its characteristic function (but one can also define it directly using unions, intersections and complements). Every formula corresponds in a natural way to a circuit, with the gates of the circuit computing the Boolean operations in the formula. This circuit has two properties that distinguish it from the circuits in the definition of circuit complexity. #The underlying directed acyclic graph is a tree. #The inputs can be duplicated. In other words, the formula complexity of a function is a bit like the circuit complexity, but you insist that the circuit has a tree structure, while compensating for that by allowing the same input to be used at several different leaves. It is trivial that formula complexity is a formal complexity measure. (To spell out one of the steps of the proof: if you want to show that $$\mu(U\cap V)\leq\mu(U)+\mu(V)$$, pick minimal formulae $$\phi$$ and $$\psi$$ for $$U$$ and $$V$$ and use the formula $$\phi\wedge\psi$$ for $$U\cap V$$.) It is also trivial that if $$\mu$$ is a formal complexity measure, then $$\mu(A)$$ cannot be bigger than the formula complexity of $$A$$. (Prove it by induction.) This leads us straight to our first problem with using a formal complexity measure, which is that a lower bound for $$\mu(A)$$ gives us a lower bound for the formula complexity of $$A$$ rather than for the circuit complexity. This would be all right if the two were in some sense comparable: perhaps a sufficiently good lower bound for the formula complexity would imply a superpolynomial lower bound for the circuit complexity. But are they likely to be comparable? [[AssessPotentialLemma|Is formula complexity comparable to circuit complexity?]] !A second problem with using a formal complexity measure to obtain circuit complexity lower bounds It appears that formulae are much less powerful than circuits. It is therefore rather annoying that nobody knows even how to prove a superpolynomial lower bound for the formula complexity of any function in NP. This is both good news and bad news. The good news is that it gives us the option of lowering our sights: such a bound wouldn't show that P$$\ne$$NP, but it would still solve a major open problem in theoretical computer science. So it is worth considering. [[TryWeakerQuestion|Can we prove a superpolynomial lower bound for formula complexity?]].  !!Parent page We are trying to [[find an efficient Ramsey lift that takes a 2-basic set to a 1-basic set|How easy is it to lift a 2-basic set to a 1-basic set?]] !Introduction Let $$T$$ be a tree. We can define a smallish Ramsey lift $$\pi:T'\to T$$ as follows. Let $$k$$ be a small integer. Then $$T'$$ consists of paths $$((x_1,\sigma),(x_2,u),x_3,\dots,x_n)$$ with the following properties. #$$\sigma$$ is a Player I strategy for playing the first $$k$$ moves of the game on $$T'$$. #$$u$$ is a path of length $$k$$ in $$T$$ that is compatible with $$\sigma$$. (In other words, $$(u_1,\dots,u_k)$$ could be the first $$k$$ moves of the game if Player I uses the strategy $$\sigma$$ for those $$k$$ moves. #$$(x_1,\dots,x_k)=(u_1,\dots,u_k)$$. The map $$\pi$$ takes the above path to $$(x_1,x_2,\dots, x_n)$$. It is straightforward to verify that $$\pi$$ takes """I-winning""" sets to """I-winning""" sets and """II-winning""" sets to """II-winning""" sets. We would like to know whether there is an analogue of this construction for the shrinking-neighbourhoods game. !First attempt We can think of what we are looking for as being like the trivial lift but restricted to the first $$k$$ moves. Here is the definition of the trivial lift (given [[here|Is there an easy Ramsey lifting that makes all sets simple?]] -- see the fifth attempt) $$\pi:Y\to X$$ itself. $$Y$$ consists of all sequences of the form $$y=(y_1,\dots,y_n)$$ with the following properties. #For exactly one $$i$$ between 1 and $$n/2$$, we have $$y_i=\sigma$$, where $$\sigma$$ is a """Player-I""" strategy for $$X$$ such that the first move consists of a specification of $$x_i$$. #For exactly one $$j$$ between $$n/2+1$$ and $$n$$, we have $$y_j=x$$, where $$x$$ is an element of $$X$$ that could arise during a run of the game with Player I playing with the strategy $$\sigma$$ and Player II responding with a specification of $$x_j$$. #$$y_r=x_r$$ for every $$r$$ not equal to either $$i$$ or $$j$$. The map $$\pi$$ takes a sequence $$y$$ as just described to the sequence $$x$$. Now let me try to write down the obvious "restriction" of this lift to the first $$k$$ moves. $$Y$$ consists of all sequences of the form $$y=(y_1,\dots,y_n)$$ with the following properties. #For exactly one $$i$$ between 1 and $$n/2$$, we have $$y_i=\sigma$$, where $$\sigma$$ is a """Player-I""" strategy for $$X$$ for the first $$k$$ moves, such that the first move of $$\sigma$$ consists of a specification of $$x_i$$. #For exactly one $$j$$ between $$n/2+1$$ and $$n$$, we have $$y_j=u$$, where $$u$$ is a sequence of $$k$$ coordinate specifications that could arise as the first $$k$$ specifications if Player I uses the strategy $$\sigma$$. #$$y_r=\gamma_r$$ for every $$r$$ not equal to either $$i$$ or $$j$$ if one of the coordinate specifications in $$u$$ is $$x_r=\gamma_r$$. (In other words, the specifications in the sequence $$u$$ are obeyed.) #Every remaining $$y_r$$ is equal to some $$\gamma_r\in\Gamma$$. #The sequence $$x=(\gamma_1,\dots,\gamma_n)$$ belongs to $$X$$. The map $$\pi$$ takes a sequence $$y$$ as just described to the sequence $$x$$. What do we get if we set $$k=2$$? By this I mean that the players get one move each. A Player I strategy just consists of a choice of first move, and a Player II response is merely a second move. Ah, what makes things complicated is that the $$i$$ and $$j$$ above are not necessarily the same as the $$i$$ and $$j$$ associated with the basic sets $$A$$ and $$B$$. !Conclusion For now I don't feel as though I'm getting very far with this idea for finding a lift. It may be time to try the imitating-Martin approach. [[Return to parent page|How easy is it to lift a 2-basic set to a 1-basic set?]] This sitemap is intended to make it easy to take in the global tree structure of the notebook. OT denotes a page with the """OpenTask""" tag. PDE stands for "probable dead end" (with apologies). QA stands for "question answered". (I may have missed a few of these.) [[Does P=NP?]] >[[Do NP functions have polynomial circuit complexity?]] >>[[Is there a useful definition of simplicity?]] >>>[[Is there a useful numerical measure of simplicity?]] >>>>[[Is there a useful formal complexity measure?]] >>>>>[[Is formula complexity comparable to circuit complexity?]] (PDE) >>>>> >>>>>[[Can we prove a superpolynomial lower bound for formula complexity?]] (PDE) >>>>[[Is there a useful numerical complexity measure with a more stringent growth condition?]] (PDE) >>>[[Why does nothing seem to work?]] >>>>[[A model of random functions of circuit complexity at most m]] >>>> >>>>[[How could one conceivably get round the natural proofs barrier?]] >>>>>[[What could a "strange" simplicity property conceivably be like?]] >>>>>>For descendants of the above page, see below
 [[What could a "strange" simplicity property conceivably be like?]] >[[How can one deduce a universal statement from an existential one?]] (OT) > >[[What sort of set could squeeze between a random-looking NP set and a random-looking co-NP set?]] (OT) >>[[Could we use a Sigma_2 property?]] >>>[[What might a proof using a Pi_2 property look like?]] >>>>[[What counts as an "interesting" consequence of low circuit complexity?]] >>>>>[[Is there an important difference between "can be deduced from" and "is implied by"?]] >[[Given what I now think, what might a "strange" simplicity property look like?]] >>[[Advantages and disadvantages of Borel determinacy as a potential analogue]] >> >>[[A brief primer on Martin's Borel determinacy theorem]] >> >>[[What might a finitary analogue of Martin's theorem look like?]] (OT) >>>[[Can we find an analogue of Martin's theorem using the obvious game?]] >>>>[[Are games with low-complexity payoff sets "simply" determined?]] (OT,PDE) >>>> >>>>[[Can games with low-complexity payoff sets be lifted to not much larger games with payoff sets that are closed and open?]] (OT, PDE) >>>[[Can we find an analogue of Martin's theorem using the obvious invariant game?]] (PDE) >>> >>>[[Can we find an analogue of Martin's theorem using a more complicated game?]] (PDE) >>> >>>[[Can we find an analogue of Martin's theorem by thinking about more general Ramsey properties?]] >>>>[[How large an alphabet do we need to make a set basic?]] >>>> >>>>[[If we want a Ramsey property, then what features should it have?]] >>>>>[[What two classes of sets could serve as a "symmetric analogue" of the classes of strategic subtrees for Player I and Player II?]] >>>>>>For descendants of the above page, see below >>>>[[Is there a realistic proposal for how an eventual proof might look?]] >>>> >>>>[[What is the difference between this set-up and the invariant game?]]
 [[What two classes of sets could serve as a "symmetric analogue" of the classes of strategic subtrees for Player I and Player II?]] >[[Is a tree a special kind of complexity structure?]] > >[[What is the right definition of a "half-dimensional set"?]] >>[[Is it easy to Ramsey-lift an arbitrary set to a simple set?]] (OT) >>>[[Does the trivial lift have the Ramsey property?]] (OT) >>[[Can all sets be Ramsey lifted?]] >>>[[OK, what is a half-dimensional subset of the discrete cube?]] (OT) >>> >>>[[Can we lift an arbitrary set in an analogous way to the way we do it for trees?]] >>[[What would be a good analogue of the Gale-Stewart theorem?]] >> >>[[Can we use a DAG picture to define half-dimensional sets?]] >>>[[Is the shrinking neighbourhoods game likely to work for our purposes?]] >>>>[[Is there an easy Ramsey lifting that makes all sets simple?]] (QA) >>>> >>>>[[What do we need in order to show that sets of low circuit complexity can be efficiently lifted?]] >>>>>[[How easy is it to lift a 2-basic set to a 1-basic set?]] (PDE) >>>>>>For descendants of the above page, see below. >>>>>[[How easy is it to lift a "closed" set to an "open" set?]] >>>>>>For descendants of the above page, see below. >>>>[[Is there an efficient Ramsey lift for the parity function?]] (OT) >>>>>[[A proof that a certain lift is not Ramsey]] (QA) >>>>> >>>>>[[Another lift that is not Ramsey]] (QA) >>>>[[Are there some interesting examples of efficient Ramsey lifts?]] >>>>>[[Must all non-trivial Ramsey lifts use large alphabets?]] >>>>>>For descendants of the above page, see below >>>>>[[When n=2, is it always possible to find an efficient Ramsey lift that simplifies some set?]] (QA) >>>>> >>>>>[[Are there interesting examples of lifts that preserve the winning sets of one player?]] >>>>[[How much extra information is needed to shift a basic set?]] (OT) >>>>>[[If we add a bounded amount of information in two additional first moves, must the lift fail to be Ramsey?]] (OT) >>>>>>[[Does every point belong to a minimal winning set?]] (OT) >>>>>> >>>>>>[[If we add a bounded amount of information when n=2, then what happens?]] >>>>[[How discouraging is it that Martin can lift any finite collection of Borel sets simultaneously to very simple sets?]] >>>>>[[Can we outlaw the use of finite determinacy?]]
 [[How easy is it to lift a 2-basic set to a 1-basic set?]] (PDE) >[[Is there an equivalent of the small Ramsey lifts that there are for trees?]] > >[[Is there any reason to think that it is not possible to lift 2-basic sets to 1-basic sets efficiently?]] > >[[Can we find a lift that is modelled on Martin's lift from closed games to open games?]] >>[[Can we find a Ramsey lift by an iterative procedure?]]
 [[How easy is it to lift a "closed" set to an "open" set?]] >[[Can we find an efficient lift by imitating Martin's proof and using an iterative procedure?]] >>[[How should we define an iterative procedure more precisely?]] >> >>[[Does the suggested simplification work?]] >> >>[[Is there a whole class of methods that are ruled out for similar reasons?]] (OT)
 [[Must all non-trivial Ramsey lifts use large alphabets?]] >[[Can trivial lifts be used to simplify sets?]] >>[[Can super-trivial lifts reduce circuit complexity?]] (QA) >> >>[[Can random subsets of super-trivial lifts reduce circuit complexity?]] (QA?) >> >>[[Can a trivial lift lift a non-basic set to a basic set?]] (QA) >> >>[[If a trivial lift of a set is the intersection of two basic sets, must the original set be the intersection of two basic sets?]] (QA) >[[Must all non-trivial Ramsey lifts use large alphabets when n=2?]] (QA) > >[[Must all non-trivial Ramsey lifts use large alphabets when n=4?]] (OT) Open maths notebooks !!Parent page We want to narrow down further [[the search for a "strange" simplicity property|Given what I now think, what might a "strange" simplicity property look like?]]. !Introduction Although there are some reasons to think that it will be difficult to make this idea work, it seems to be worth investigating whether a finitary analogue of Martin's proof could provide us with a non-trivial consequence of low circuit complexity. !What should play the role that the sequence game plays in the infinite case? Given a subset $$A\subset\{0,1\}^n$$, there are various ways that we might consider creating an analogue of the infinitary game that is derived from subsets of $$[T]$$ when $$T$$ is an infinite pruned tree. Let me list a few options. !!The obvious game This one is just a direct imitation of what we do in the infinite case. We define a game for two players. They build up an $$n$$-bit sequence, taking turns to choose the bits in the order $$x_1,x_2,\dots,x_n$$. As I commented elsewhere, a disturbing feature of this game is that the tree structure that it imposes on the set of 01-sequences of length at most $$n$$ is very far from invariant under permutation of the ground set. However, it is not clear at this stage whether that lack of invariance is going to be a serious problem. !!The obvious invariant game If we want a game that is invariant under permutation of the ground set, then there is an obvious way of defining it. Instead of asking the two players to choose the bits in the order $$x_1,x_2,\dots,x_n$$, we allow them to specify any bit that has not yet been specified. An encouraging feature of this game is that instances of it have been studied in the literature. For example, //maker-breaker games// on graphs are games where the players take turns saying whether an edge that has not yet been specified belongs or does not belong to the graph. (In these games, the payoff set is monotone, so one can assume that one player always puts edges into the graph and the other makes sure that edges are not in the graph.) !!A more complicated class of games I'm not sure there is a good reason for studying these, but I thought of them before thinking about Borel determinacy. One can think of the two previous classes of games as games where the players take turns to specify affine coordinate hyperplanes in which the sequence must live. In the second game, the only constraint is that the set of sequences that belong to all the affine coordinate hyperplanes mentioned so far must be non-empty (which is true if and only if it is never the case that the hyperplanes $$x_i=0$$ and $$x_i=1$$ have both been mentioned). Coordinate hyperplanes are particularly simple sets, and it may turn out that the games they give rise to are for that reason "too simple", and liable to lead to complexity measures that blow up for the parity function. But once one thinks in these terms, it is easy to generalize. A mild generalization would be to allow arbitrary hyperplanes (thinking of $$\{0,1\}^n$$ as a vector space over $$\mathbb{F}_2$$). A more complicated generalization would be to allow highly non-linear sets. For example, one could allow the players to specify sets that correspond to clauses of 3-SAT -- that is, sets like $$x_3\vee\neg x_6\vee x_8$$. (Of course, that's a formula rather than a set, but I am using it as shorthand for the set of $$x$$ such that either $$x_3=1$$ or $$x_6=0$$ or $$x_8=1$$.) Just to be clear, the rules of this "3-SAT game" would be as follows. The players would take turns to specify 3-SAT clauses such as the above. The main two rules would be as follows. #Each move must decrease the number of sequences that satisfy all the clauses. #After each move there must be at least one sequence that satisfies all the clauses. Of course, these rules force the game to terminate: it terminates when there is just one sequence that satisfies all the clauses, with Player I winning if that sequence belongs to $$A$$ and Player II winning otherwise. Given that the problem of determining whether a bunch of clauses of size 3 can be simultaneously satisfied is possibly the most famous ~NP-complete problem, it is clear that this game is significantly more complicated than the games discussed above. Indeed, it seems to be hard to analyse even when the payoff sets are very simple. ''//Open Task: Analyse this game for some very simple payoff sets, such as $$\{x\in\{0,1\}^n:x_1=1\}$$.//'' ''Remark:'' [[Bogdan points out|http://gowers.wordpress.com/2013/11/03/dbd1-initial-post/#comment-43827]] that that payoff set is //too// simple, as there is a very easy strategy for Player I. But the parity function looks as though it might be more interesting. !!Generalizing the notion of a game Maybe we shouldn't be too hung up on games. If we think of determinacy as a Ramsey property, then we can see Martin's proof as the proof of a Ramsey theorem where the structure to be found is a certain kind of subtree. (For details, see the section Strategic Subtrees of [[the primer on Martin's theorem|A brief primer on Martin's Borel determinacy theorem]].) Perhaps we could devise another Ramsey theorem and try to find a proof that is to that theorem as Martin's proof (very lightly sketched in the primer) is to determinacy. !What should play the role of the topology? This question is rather easier, at least for subsets of $$\{0,1\}^n$$. For infinite 01-sequences, a basic open set is one that you obtain by specifying some finite set of coordinates. It is natural to take "small" as the analogue of "finite" here, though precisely what counts as small is not clear: it might be "bounded above by a constant independent of $$n$$" or it might be "of at most logarithmic size" or it might be something else. An "open set" would then be any union of basic open sets: it would correspond to a formula in [[disjunctive normal form|http://en.wikipedia.org/wiki/Disjunctive_normal_form]] in which all the clauses were small. !What should play the role of determinacy? All finite games are determined. So what should we be trying to prove? I have two suggestions. The first is not to worry about the fact that all finite games are determined, and simply concentrate on how to prove this fact for certain classes of sets. For example, maybe for sets of low circuit complexity we can prove determinacy using a lifting that is much smaller than what you need for arbitrary sets. The second is to try to prove something stronger: that for a set of low circuit complexity one player has not just a winning strategy but a winning strategy of some particular "simple" kind. For example, perhaps the moves that the players make should not be allowed to depend in too complicated a way on the moves that have been made so far. !What next? There are several suggestions here, and it is not clear which ones are the best. So I feel forced to think about all of them, starting with the simplest. Can we find an interesting analogue of Martin's theorem using the obvious game? [[LookForSomethingMoreSpecific|Can we find an analogue of Martin's theorem using the obvious game?]] Can we find an interesting analogue of Martin's theorem using the obvious invariant game? [[LookForSomethingMoreSpecific|Can we find an analogue of Martin's theorem using the obvious invariant game?]] Can we find an interesting analogue of Martin's theorem using a more complicated game? [[LookForSomethingMoreSpecific|Can we find an analogue of Martin's theorem using a more complicated game?]] Can we find an interesting analogue of Martin's theorem by thinking of determinacy as a Ramsey property and looking for more general Ramsey properties? [[LookForSomethingMoreSpecific|Can we find an analogue of Martin's theorem by thinking about more general Ramsey properties?]] Orthogonal to some of the above questions is the question of whether we can show that sets of low complexity give rise to games for which there is a "simple" winning strategy. That too should be discussed. !!Parent page We are trying to [[find an efficient lift by imitating Martin's proof and using an iterative procedure|Can we find an efficient lift by imitating Martin's proof and using an iterative procedure?]]. !Introduction While trying to carry about the iterative programme set out in the parent page, I got impatient and tried to jump to what I guessed might be the end of the process. But I ran into a difficulty, and I now want to understand how general that difficulty was. !What was the difficulty? Rather than describe the specific difficulty that occurred (it can be found on [[a sister page to this one|Does the suggested simplification work?]]) I will try to describe it in more general terms. I had a 1-closed set $$A\subset X$$ and was looking for a complexity structure $$Y$$ and a map $$\pi:Y\to X$$ that preserved winning sets. I wanted $$Y$$ to have the following form. The sequences in $$Y$$ should all be of the form $$((\gamma_1,w),\dots,(\gamma_{n/2},w),(\gamma_{n/2+1},u),\dots,(\gamma_n,u))$$, where $$(\gamma_1,\dots,\gamma_n)$$ is a sequence in $$X$$. The map $$\pi$$ would take such a sequence to the sequence $$(\gamma_1,\dots,\gamma_n)$$. I also wanted $$u$$ to determine whether $$x=(\gamma_1,\dots,\gamma_n)\in A$$. That is, $$u$$ should belong either to $$U_1$$ or to $$U_2$$. If it belongs to $$U_1$$, then $$x\in A$$ and if it belongs to $$U_2$$, then $$x\notin A$$. Let $$X_{w,u}$$ be the subset of $$X$$ consisting of all sequences $$(\gamma_1,\dots,\gamma_n)$$ such that $$((\gamma_1,w),\dots,(\gamma_{n/2},w),(\gamma_{n/2+1},u),\dots,(\gamma_n,u))\in X$$. We can think of the auxiliary game as follows. Player I makes a move $$x_i=\gamma_i$$ in the original game and then offers Player II a choice of non-empty subsets of $$\{x\in X:x_i=\gamma_i\}$$. The subsets offered are the sets $$X_{w,u}\cap\{x\in X:x_i=\gamma_i\}$$. Player II plays a response $$x_j=\gamma_j$$ and chooses one of those subsets, doing so in such a way that it has non-empty intersection with $$\{x\in X:x_i=\gamma_i,x_j=\gamma_j\}$$. So between the two of them, Player I and Player II narrow the game down to one of the sets $$X_{w,u}$$ at the same time as playing their first two moves. What does it take for a winning set for Player I in the auxiliary game to project to a winning set for Player I in the original game? I want to ask this question independently of the set $$A$$: later we will need to add the condition that each $$X_{w,u}$$ should be a subset of either $$A$$ or $$A^c$$. Let $$Z$$ be a winning set for Player I in the auxiliary game and let $$\sigma$$ be a winning strategy for getting into $$Z$$. This strategy begins with a specification of the form $$y_i=(\gamma_i,w)$$. We now need to ask what sequences can possibly arise as projections of the sequence that is created by the end of the game. The answer is that Player II can make any response of the form $$y_j=(\gamma_j,u)$$ and after that can respond to $$\sigma$$ with any strategy he likes, with the rest of the game taking place inside $$X_{w,u}$$. Once the rest of the game starts, Player I has a winning strategy in the set $$X_{w,u}$$ for getting to a point in $$\pi(Z)\cap X_{w,u}$$. Writing $$Z_{w,u}$$ for $$\pi(Z)\cap X_{w,u}$$, we have that for each $$u$$ that Player II can choose, $$Z_{w,u}$$ is winning inside $$X_{w,u}$$. From that we need to be able to deduce that $$\pi(Z)$$ is winning inside $$X$$. !Modification of question To make this easier to think about, I'm going to consider a slightly simpler situation that will I hope be sufficiently similar that I can work out what happens in the simpler situation and from that work out what happens in the actual situation of interest. In the simpler situation, an auxiliary game is played as follows. Player I declares a class $$\mathcal{U}$$ of subsets of $$X$$ (this class comes from some class of classes of subsets), Player II chooses some $$U\in\mathcal{U}$$, and after that the shrinking-neighbourhoods game takes place in $$U$$. The first question I would like to ask is this. What conditions are needed on each $$\mathcal{U}$$ to ensure that if $$W$$ is a winning set for Player I in the auxiliary game, then $$\pi(W)$$ is a winning set in $$X$$. ($$\pi$$ is the map that takes the triple $$(\mathcal{U},U,x)$$ to $$x$$.) The property we now need is a simple one: if for every $$U\in\mathcal{U}$$ we choose a """I-winning""" subset $$W(U)\subset U$$, then $$\bigcup_{U\in\mathcal{U}}W(U)$$ must be a """I-winning""" set in $$X$$. Two extreme methods of achieving this are as follows. The first is to let $$\mathcal{U}$$ be the singleton $$\{X\}$$, The second is to choose a """I-winning""" set $$W$$ and let $$\mathcal{U}$$ consist of all singletons $$\{w\}$$ with $$w\in W$$. !!!An intermediate method What can be achieved in between? One method is this. Let $$\Sigma$$ be a set of game positions such that (i) it is Player I's turn and (ii) Player I has a winning strategy for reaching a position in $$\Sigma$$. For each set $$S$$ of coordinate specifications in $$\Sigma$$, define $$U(S)$$ to be the set of all sequences in $$X$$ that obey the specifications in $$S$$. Now let $$\mathcal{U}=\{U(S):S\in\Sigma\}$$. I claim that this works. That is, I claim that if for every $$U(S)$$ we choose some $$W(S)\subset U(S)$$ such that Player I has a winning strategy for reaching $$W(S)$$ if the game is played in the set $$U(S)$$, then $$\bigcup_{S\in\Sigma}W(S)$$ is a winning set for Player I in $$X$$. The rough idea of the proof is that Player I has a winning strategy for arriving at a set $$S\in\Sigma$$ of coordinate restrictions, after which the game takes place inside $$U(S)$$, giving Player I a winning strategy for reaching a point in $$W(S)$$. But the proof needs to be written out carefully, since it feels slightly dodgy. The main point I want to check is that the following two statements are equivalent. #Player I has a winning strategy for reaching a point in $$W(S)$$ if the entire game takes place inside $$U(S)$$. #Player I has a winning strategy for reaching a point in $$W(S)$$ if the current game position is $$S$$ (in the sense that the coordinate specifications so far are precisely those in $$S$$). The difference between these two situations is that the game we are talking about for the second is the special case of the game we are talking about for the first where all the specifications in $$S$$ occur before any further moves. Note that in one sense the specifications in $$S$$ do not make any difference, since (by definition) they are satisfied by every point in $$U(S)$$. However, they give players a chance of "opting out" of a move. Suppose first that Player I has a winning strategy in the second situation. She can win in the first situation as follows. She begins by pretending that she is in the second game, and plays some specification of a coordinate not specified by $$S$$. She continues that way except that each time Player II plays one of the "trivial" specifications in $$S$$, she matches it with one of her own. Since there are an equal number of specifications in $$S$$ in the first half and in the second half of the coordinates, she can always do this. Now suppose that Player I does not have a winning strategy in the second situation. Then Player II has a winning strategy in the second situation and can convert it into a winning strategy in the first situation in almost exactly the same way: play a second-situation strategy except that if Player I plays an $$S$$ move then he plays one immediately afterwards. It follows that Player I does not have a winning strategy in the first situation, and we are done. !!!Proof that it works Let $$\mathcal{U}$$ be as defined above and for each $$U(S)\in\mathcal{U}$$ let $$W(S)$$ be a subset that is winning in $$U(S)$$. Then Player I has the following strategy for ending up in some $$W(S)$$. By hypothesis, she can ensure that at some stage of the game the position will be some $$S\in\Sigma$$. At that point, since $$W(S)$$ is a winning subset of $$U(S)$$, the equivalence just proved tells us that she has a winning strategy for ending up inside $$W(S)$$. Therefore, she has a winning strategy for ending up in $$\bigcup_{S\in\Sigma}W(S)$$, as claimed. v !!Strategies for Player II The second question I would like to ask about this modified game is this. Suppose that for every possible set system $$\mathcal{U}$$ that Player I has the option of playing, we choose one $$U\in\mathcal{U}$$ and a subset $$W(U)\subset U$$ that is a win for Player II inside $$U$$. What condition do we need the set of set systems to satisfy in order to guarantee that the union of all the $$W(U)$$ is a winning set for Player II in $$X$$? Again let us look at extreme examples. If there is only one $$\mathcal{U}$$, the singleton $$\{X\}$$, then we are forced to choose a winning subset of $$X$$ and we are done. If for each winning set $$V$$ for Player I we let $$\mathcal{U}(V)$$ be the set of all singletons $$\{v\}$$ such that $$v\in V$$, then we are forced to choose at least one singleton from every winning set $$V$$ for Player I. The union of those singletons must be a winning set for Player II, since its complement is, by construction, not a winning set for Player I. Now let me try to describe an intermediate situation. Let us call a set $$\Theta$$ of game positions //unavoidable// if every run of the game (whatever strategies the players use) must include a position in $$\Theta$$. A simple example is the set of all specifications of exactly four coordinates. Let us call a subset $$\Sigma$$ of $$\Theta$$ """I-winning""" if Player I has a winning strategy for getting to a set of specifications in that subset. For each $$\Sigma$$, let $$\mathcal{U}(\Sigma)=\{U(S):S\in\Sigma\}$$. (This is the same as the definition of $$\mathcal{U}$$ above, but now we are making the dependence on $$\Sigma$$ explicit.) Suppose that for every """I-winning""" subset $$\Sigma$$ of some unavoidable set $$\Theta$$ we take the class $$\mathcal{U}(\Sigma)$$. I think that will work, but need to check. What would the rough argument be? From each $$\mathcal{U}(\Sigma)$$, Player II chooses some $$U(S)$$ and then a """II-winning""" subset $$W(S)$$ of $$U(S)$$. Since Player II is selecting at least one $$S$$ from each """I-winning""" subset $$\Sigma$$ of $$\Theta$$, Player II has a winning strategy for reaching one of these specifications $$S$$. Once he does, he can play whatever the winning strategy is for $$W(S)$$ inside $$U(S)$$. An argument similar to the one above should show that this rough sketch is in fact basically correct. I think I'll take the risk for now and not check it carefully. !Where are we now? I think I have identified a fairly large class of Ramsey liftings (that is, ones that take winning sets to winning sets), except for the added small (I hope) complication that in the auxiliary game I am actually interested, the players make moves at the same time as providing extra information, rather than providing all the extra information first. What I have not done is consider what happens if we add the following crucial further condition. We are given a set $$A$$, and we insist that every set $$U(S)$$ that can possibly occur in the game described above is a subset of either $$A$$ or $$A^c$$. Before I address that, however, there is another point that concerns me more. It's that a set $$\Sigma$$ of specifications will typically be of size comparable to the size of the alphabet $$\Gamma$$, which means that if we start composing several lifts of this type, the size of the alphabet will blow up much too fast. What I tried and failed to do [[on this page|Does the suggested simplification work?]] was to get round this problem by dealing with coordinate //restrictions// (things like $$x_i\notin\Delta_i$$) rather than coordinate //specifications// (things like $$x_i=\gamma_i$$). What provoked the current page was the thought that maybe the difficulties I ran into were fundamental difficulties associated with not taking full specifications of coordinates. !Can we deal with restrictions rather than specifications? Let $$\Sigma$$ be a set of sets $$S$$ of coordinate restrictions. (I define a set of coordinate restrictions to be a set of restrictions of the form $$x_i\in\Delta_i$$.) Suppose that Player I has a winning strategy for reaching a game position where there exists $$S\in\Sigma$$ such that the specifications made so far in the game apply to precisely the coordinates restricted by $$S$$ and obey those restrictions. For each $$S$$ let $$U(S)$$ be the set of sequences in $$X$$ that obey the restrictions in $$S$$. Suppose that for every $$S\in\Sigma$$ we choose a """I-winning""" subset $$W(S)$$ of $$U(S)$$. Is the union of the sets $$W(S)$$ a """I-winning""" subset of $$X$$? The rough argument would be that Player I can begin by reaching a game position where all the coordinates restricted by $$S$$ are specified in a way that is consistent with those restrictions. This restricts the game to $$U(S)$$, after which she can force the game to end up in $$W(S)$$. Unfortunately, this rough argument is incorrect. Player I may have a winning strategy for getting to $$W(S)$$ if the game is played in $$U(S)$$, but all we have established is that Player I can ensure that the game is played in some rather small subset of $$U(S)$$ where the coordinates corresponding to $$S$$ are fully specified rather than merely restricted. My main question on this page is whether this is a serious problem, or whether we can get round it somehow. I think the best way of answering that question is to try to find an example where it //is// a problem. !A simple example Let's try taking $$\Sigma$$ to consist of the single set $$S$$, which itself consists of the single restriction $$x_1\in\Delta_1$$. Player I has an easy winning strategy for reaching a game position consistent with some $$S\in\Sigma$$: she just needs to begin with a move $$x_1=\gamma_1$$ for some $$\gamma_1\in\Delta_1$$. Now let's suppose that Player I has a winning strategy for a subset $$W$$ of $$U=\{x:x_1\in\Delta_1\}$$. By that I mean that Player I wins when the game is played inside $$U$$, so $$W$$ may not be a winning set in $$X$$. The problem I'm worried about is that Player I's winning strategy for $$W$$ inside $$U$$ may involve specifying some coordinate other than $$x_1$$ first. Let me try to give an example of this. Suppose that $$W$$ is the set of all $$x$$ such that $$x_1\in\Delta_1$$ and $$x_n=\gamma$$, and it so happens that $$x_2=x_n$$ for every $$x\in X$$ such that $$x_1\in\Delta_1$$, but that that is not the case in general. Then within $$U$$ Player I has an easy winning strategy for $$W$$: begin with the move $$x_2=\gamma$$. Player I also has an easy winning strategy for getting to $$U$$ in the first place: begin with the move $$x_1=\gamma_1$$ for some $$\gamma_1\in\Delta_1$$. But she can't put these two strategies together to obtain a winning strategy for $$W$$: there does not have to be any move that stops Player II from using his first move to specify $$x_n$$ to be something other than $$\gamma$$. !What does that example teach us? It's not clear that it is a good example, because there is a confusion arising from whose turn it is. When I say that Player I has a winning strategy for $$W$$ within $$U$$ I am assuming that she starts. But is that reasonable? It isn't the situation that occurs in the rough argument above, though I still believe that argument to be incorrect. In the rough argument, the assumption is that Player I has a winning strategy for getting to the set $$U$$ and a winning strategy for the game if it is restricted to $$U$$. But if Player I has just managed to get to $$U$$, then it would seem to be Player II's turn. In the example above, Player I does //not// have a winning strategy inside $$U$$ if it is Player II's turn. !A modified example Let $$U\subset\{0,1\}^n$$ be the set of all sequences such that $$x_1=x_n$$ or $$x_1=x_{n-1}$$. Player I has a winning strategy for getting to $$U$$, which consists in waiting until Player II has specified $$x_n$$ or $$x_{n-1}$$ and imitating the specification. Now let $$W\subset U$$ be the set of all sequences such that $$x_1=x_2$$. If both players are obliged to play within $$U$$ (which means that it is illegal to make a specification that cannot be extended to a sequence in $$U$$), then Player I has a winning strategy for $$W$$ within $$U$$, which is to play $$x_1=0$$ as her first move and $$x_2=0$$ as her second move. But Player I does not have a winning strategy for $$W$$, since Player II can wait till Player I specifies one of $$x_1$$ and $$x_2$$ and can then make both $$x_{n-1}$$ and $$x_n$$ different from that. But this example seems not to be significant either. OK, it shows that a winning subset of a winning subset does not have to be a winning subset. But that is not surprising. It is also not what we were looking for, since $$U$$ is not defined by means of independent coordinate restrictions. !Conclusion I'm getting bogged down here. ''//Open task: it would be good to sort all this out.//''  !!Parent page After narrowing down the search somewhat, we are thinking further about [[what a "strange" simplicity property might look like|Given what I now think, what might a "strange" simplicity property look like?]]. This has led us to consider Borel determinacy. !Disadvantages I'll begin with some objections to trying to prove circuit lower bounds by finding a finitary analogue of Borel determinacy. #All finite games are determined, so determinacy //doesn't// distinguish between sets of low circuit complexity and arbitrary sets. #The correct finitary analogue of Borel sets is sets that can be computed by a circuit of polynomial size //and constant depth//. #Many """NP-complete""" functions are monotone, and monotone games are not just determined, but determined in a very simple way: one player's best strategy is to play 1s the whole time and the other player's best strategy is to play 0s the whole time. #The game that is created out of a set depends on the ordering you give to the coordinates. In the infinite case that doesn't matter too much, since what really counts is that every finite set of coordinate indices is bounded. But in the finite case, there is a world of difference between the singleton $$\{1\}$$ and the singleton $$\{n\}$$. !Defence against the disadvantages #This does not rule out the possibility that sets of low circuit complexity give rise to games that have "simple" winning strategies in some sense. #This is definitely a worrying objection. However, the proof of Borel determinacy is sufficiently different from the proofs of other facts about Borel sets (in particular, requiring multiple iterations of the power-set axiom) that it is just possible that there is a finitary analogue that applies to a wider class of circuits -- perhaps even all circuits of polynomial size. #The proof of Borel determinacy proceeds by identifying a //stronger property// and showing that it is closed under complements and countable unions and intersections. Determinacy is not even closed under finite intersections. So there might be a hope of using a finitary analogue of the stronger property. #This is another worrying objection. However, maybe it would be possible to modify the definition in the finite case to make things more symmetric. To give a simple suggestion: perhaps the players could choose an arbitrary bit at each stage that they want to specify, rather than being forced to choose the next bit in the sequence. !Advantages #In the infinitary world, determinacy appears to be a very strange property. As mentioned above, to prove it for Borel sets requires multiple iterations of the power-set axiom. To prove it for analytic sets requires large-cardinal axioms that go beyond ZFC. So there appears to be a very strange distinction -- exactly what we are hoping to find in the finite case! #Strategies are complicated things: functions defined on all sequences of length less than $$n$$. The statement that such a strategy is winning is also somewhat complicated: it involves a universal quantification over every sequence of moves that the other player could make. So the statement, "There exists a winning strategy for $$A$$ for Player I" is naturally a $$\Sigma_2$$ statement, as is the statement that $$A$$ is determined. Of course, determinacy is also a trivial statement, since all finite games are determined, but if we add conditions to the strategy then it may become genuinely $$\Sigma_2$$. #As already noted, determinacy itself, even with extra conditions added, is unlikely to be the "strange" distinguishing property we are looking for. But the property that Martin uses to //prove// determinacy also involves a few quantifier alternations. What's more, the proof that Borel sets have this property is definitely not trivial in the unsatisfactory sense that we have been worried about. So if we could find a finitary analogue, then we would certainly have an "interesting" consequence of low circuit complexity. !Is there any hope of proving that some NP function does //not// have the property we identify? I have set my sights quite low here: I would be very pleased with just finding a non-trivial consequence of low circuit complexity. However, I have a small and probably rather fanciful idea for how one might go about proving that this consequence does not apply to all functions in NP. Again it comes from an analogy with the infinite world. In the infinite world, Martin's proof of Borel determinacy involves, as I have said, multiple iterations of the power-set axiom. However, there is more to it: work of Harvey Friedman (that predates Martin's proof) shows that these iterations are necessary. It turns out that determinacy of Borel sets of level $$\alpha$$ doesn't actually //imply// that the power set axiom can be iterated a certain number of times. Roughly speaking, if you don't have the power set axiom, then it is consistent that a suitably iterated power set of $$\mathbb{N}$$ exists but that determinacy fails for Borel sets of a comparable level to the number of iterations. (For a less rough explanation, written by someone who actually understands this stuff, see [[this blog comment|http://gowers.wordpress.com/2013/08/23/determinacy-of-borel-games-i/#comment-42098]].) The proof that determinacy of analytic sets requires large cardinals is similar. Since I haven't discussed Martin's proof yet, I must now be rather vague. The proof involves constructing an auxiliary object of a certain kind. One might hope that in the finite case, the auxiliary object would have to be extremely large -- of tower size, say (so that we have iterated a power set many times). Unfortunately, this doesn't appear to be the case: for at least one definition of auxiliary object, the fact that all finite games are determined allows us to build an auxiliary object of doubly exponential size. However, perhaps we can do better for games of low circuit complexity, and perhaps we cannot do better for general NP games. And perhaps the proof of the latter would be in some way metamathematical: showing, for instance, that in some weak system in which exponentiation is not allowed, it is consistent that the auxiliary object does not exist. !One more advantage There is something about games that smells right. Before the idea occurred to me of trying to model a proof on Martin's proof of Borel determinacy, I had already come up with the idea of looking at games, but for a completely different reason. I'm not sure how convincing I find that reason now, but let me at least give it. Recall that in one formulation of the problem, we were trying to find a property that was non-trivially intermediate between a random-looking NP property and a random looking """co-NP""" property. (The """co-NP""" property was "does not differ from $$g$$ by a function of circuit complexity at most $$m$$".) One difficulty with trying to find such a property is that a typical sentence you write down starts with an existential quantifier or a universal quantifier. It somehow feels as though if it starts with an existential quantifier then it is likely to be "too close" to the NP property and if it starts with a universal quantifier then it is likely to be "too close" to the """co-NP property""". So we would prefer something more "genuinely intermediate". When one has a thought like that, games come in naturally: they typically involve an unbounded sequence of quantifiers. True, the statement that the first player has a winning strategy always gives us a sequence that starts with an existential quantifier (there exists a first move for Player I such that for every first move of Player II there exists a second move for Player I such that for every ... etc.). But if you have a long sequence of alternations of quantifiers, then somehow the asymmetry matters less. I was also encouraged by the simple argument that shows that the first player has a winning strategy in Hex. The argument is a simple strategy steal: if the second player had a winning strategy, then the first player could play as though the second player had made an initial move, and would then win, which is a contradiction. And it can be shown that one or other player must win. What I found encouraging about this argument was that it showed the existence of a very complicated object -- a winning strategy for Hex -- using a very simple proof -- a strategy stealing argument. Could something like this be done to prove that P$$\ne$$NP? Could it give us our desired "strange" property? I didn't get very far pursuing that thought. Nevertheless, the coincidence of the notion of games coming up for two different reasons was mildly encouraging.  !!Parent page We are considering [[why it is so hard to give a satisfactory definition of simplicity for the purposes of proving circuit complexity lower bounds|Why does nothing seem to work?]]. As part of the explanation, it is useful to have a notion of a "random low-complexity function". !A probability distribution on functions of low circuit complexity Let us define a //3-bit scrambler// to be a function $$g_{A,\pi}$$ of the following form. Let $$A=\{i_1,i_2,i_3\}$$ be a subset of $$\{1,2,\dots,n\}$$ of size 3, and assume for convenience that $$i_1<i_2<i_3$$. Let $$\pi$$ be a permutation of $$\{0,1\}^3$$. (That is, it takes the eight points in $$\{0,1\}^3$$ and permutes them in some way -- it doesn't matter how.) Then $$g_{A,\pi}$$ takes an $$n$$-bit Boolean sequence $$(x_1,\dots,x_n)$$ and "does $$\pi$$ to $$(x_{i_1},x_{i_2},x_{i_3})$$". That informal definition should be enough for most people, but here is a more formal one. Let's define $$P_A$$ to be the projection that takes an $$n$$-bit sequence $$(x_1,\dots,x_n)$$ to the sequence $$(x_{i_1},x_{i_2},x_{i_3})$$, and let's define $$I_A$$ to be the "insertion" that takes a pair of sequences $$(x_1,\dots,x_n)$$ and $$(y_1,y_2,y_3)$$ and replaces the bits $$x_{i_1},x_{i_2}$$ and $$x_{i_3}$$ by $$y_1,y_2$$ and $$y_3$$, respectively. Finally, if $$x=(x_1,\dots,x_n)$$ is an $$n$$-bit sequence, define $$g_{A,\pi}(x)$$ to be $$I_A(x,\pi(P_A(x)))$$. In other words, we isolate the bits in $$A$$, apply the permutation $$\pi:\{0,1\}^3\to\{0,1\}^3$$, and then stick the resulting three bits back into the slots where the original three bits came from. A simple example of a 3-bit scrambler is the map that takes an $$n$$-bit sequence and performs the following operation. If the first three bits are 000, then it replaces them by 001; if the first three bits are 001, then it replaces them by 000; otherwise it does nothing. It is easy to see that any 3-bit scrambler can be created using a circuit of bounded size. Therefore, a composition of $$m$$ 3-bit scramblers has circuit complexity at most $$Cm$$ for some absolute constant $$C$$. What's nice about 3-bit scramblers is that they give us a big supply of pretty random looking functions of low circuit complexity: you just pick a random sequence of 3-bit scramblers and compose them. That gives you a function from $$\{0,1\}^n$$ to $$\{0,1\}^n$$, but if you want a function from $$\{0,1\}^n$$ to $$\{0,1\}$$ you can simply take the first digit. Click here to go back to the page [[Why does nothing seem to work?]]  /*** |''Name''|RandomSortFilter| |''Version''|0.1.2| !Description Updates the sort filter to take a keyword *random !Usage {{{ [sort[*random]] }}} ***/ //{{{ (function() { var _sort = config.filters.sort; config.filters.sort = function(results,match) { if(match[3] === "*random") { results = results.sort(function(a, b) { var r = Math.random(); return r < 0.5 ? -1 : 1; }); return results; } else { return _sort.apply(this, arguments); } }; })(); //}}}  !!Parent page Our aim is to prove [[that there exists a function in NP that has superpolynomial circuit complexity|Do NP functions have polynomial circuit complexity?]]. This page concerns a natural approach to this question. !Introduction We have considered a natural approach, which is to come up with a definition of simplicity with the following properties. *The coordinate hyperplanes $$E_i$$ are very simple. *The intersection of two sets is not much less simple than the sets themselves. *The union of two sets is not much less simple than the sets themselves. *The complement of a set is not much less simple than the set itself. *Some suitable NP set $$A$$ is not at all simple. This definition suggests that simplicity should be a matter of degree, which does indeed make good sense, since every function can be computed by a circuit of size at most $$C2^n\log n$$. (This is an easy exercise. You express the property of being in the set $$A$$ in [[disjunctive normal form|http://en.wikipedia.org/wiki/Disjunctive_normal_form]] in a trivial way: you belong to $$A$$ if you are equal to one of the following at most $$2^n$$ points. You then write down the corresponding circuit. The log factor comes from the fact that I am allowing intersections and unions of at most two previous sets but one needs intersections and unions of $$n$$ sets.) Can we come up with a suitable definition? !!First attempt The fact that simplicity will have to be a matter of degree suggests that we might want to look for a numerical measure of simplicity, obtaining an upper bound for this measure for all sets of polynomial circuit complexity and a larger lower bound for some given set in NP. It would be good to think about whether such a measure is likely to exist and be useful. [[LookForSomethingMoreSpecific|Is there a useful numerical measure of simplicity?]]
 The conclusion of the line of enquiry just linked to is that it is unlikely that a numerical measure of simplicity will enable us to prove interesting lower bounds for circuit complexity. But what does that mean? For example, circuit complexity itself is a numerical measure of complexity (or equivalently simplicity). When I say that a numerical measure is insufficient, I mean something slightly more precise. I mean that an inductive argument that bounds some number $$\mu(U\cap V)$$ solely in terms of numbers $$\mu(U)$$ and $$\mu(V)$$ is unlikely to work. !!Second attempt It is not immediately obvious what else one can do. However, there is a very ingenious idea of Razborov called the //method of approximations//, which goes back to his work on monotone circuit complexity. (A //monotone circuit// is one where NOT gates are not allowed. It corresponds to a straight-line computation where one is not allowed to take complements.) See [[this paper of Alon and Boppana|http://tau.ac.il/~nogaa/PDFS/Publications/The%20monotone%20circuit%20complexity%20of%20Boolean%20functions.pdf]] or [[this exposition of mine|http://gowers.files.wordpress.com/2009/05/razborov2.pdf]], particularly Section 2, for more details. I am not going to say much about this method here, because Razborov has demonstrated rather convincingly that it is unlikely to be useful for proving general (as opposed to monotone) circuit complexity lower bounds. See [[his paper on the topic|http://people.cs.uchicago.edu/~razborov/files/approx.pdf]] for more details.
 When idea after idea fails to work, it is often worth stepping back and trying to think about //why// all the ideas fail to work. Let us turn to that question now. [[TryToDiagnoseDifficulty|Why does nothing seem to work?]]  /*** |''Name''|TiddlySpaceToolbar| |''Description''|augments tiddler toolbar commands with SVG icons| |''Author''|Osmosoft| |''Version''|0.6.6| |''Status''|@@beta@@| |''Source''|http://github.com/TiddlySpace/tiddlyspace/raw/master/src/plugins/TiddlySpaceToolbar.js| |''CodeRepository''|http://github.com/TiddlySpace/tiddlyspace| |''License''|[[BSD|http://www.opensource.org/licenses/bsd-license.php]]| |''CoreVersion''|2.5.0| |''Requires''|ImageMacroPlugin| |''Keywords''|toolbar icons SVG| !Description replaces tiddler toolbar commands with SVG icons if available !Notes requires [[ImageMacroPlugin|http://svn.tiddlywiki.org/Trunk/contributors/JonRobson/plugins/ImageMacroPlugin/plugins/ImageMacroPlugin.tid]] SVG icons are drawn from tiddlers titled {{{<command>.svg}}} In readonly mode a tiddler called {{{<command>ReadOnly.svg}}} will be used if it exists. !TODO * rename (IconToolbarPlugin?) * support more than one more popup menu in the toolbar. !Code ***/ //{{{ (function($) {

if(!config.macros.image) {
throw "Missing dependency: ImageMacroPlugin";
}

var macro = config.macros.toolbar;

macro.icons = {
cloneTiddler: "editTiddler"
};

var _handler = macro.handler;
macro.handler = function(place, macroName, params, wikifier,
paramString, tiddler) {
var toolbar = $(place); toolbar.attr({ refresh: "macro", macroName: macroName }).data("args", arguments); var status = _handler.apply(this, arguments); if(tiddler.isReadOnly()) { toolbar.addClass("toolbarReadOnly"); } else { toolbar.removeClass("toolbarReadOnly"); } var parsedParams = paramString.parseParams("name")[0]; if(parsedParams.icons && parsedParams.icons == "yes") { this.augmentCommandButtons(place); } if(parsedParams.more && parsedParams.more == "popup") { // note we must override the onclick event like in createTiddlyButton // otherwise the click event is the popup AND the slider$(".moreCommand", place).each(function(i, el) {
el.onclick = macro.onClickMorePopUp;
});
// buttons that are after a less command should not be in more menu.
$(".lessCommand ~ .button", place).appendTo(place);$(".lessCommand", place).remove();
}
return status;
};

macro.refresh = function(place, params) {
var args = $(place).empty().data("args"); this.handler.apply(this, args); }; var imageMacro = config.macros.image; macro.augmentCommandButtons = function(toolbar) {$(".button", toolbar).each(function(i, el) {
var cmd = $(el).attr("commandname"); cmd = cmd ? cmd : "moreCommand"; // XXX: special-casing of moreCommand due to ticket #1234 var icon = store.tiddlerExists(cmd) ? cmd : macro.icons[cmd]; var text =$(el).text();
}
}
if(store.tiddlerExists(icon)) {
$(el).css({display: "inline-block"}).empty(); imageMacro.renderImage(el, icon, { alt: text }); } }); }; // provide onClickMore to provide extra commands in a popup macro.onClickMorePopUp = function(ev) { ev = ev || window.event; var sibling = this.nextSibling; if(sibling) { var commands = sibling.childNodes; var popup = Popup.create(this);$(popup).addClass("taggedTiddlerList");
for(var i = 0; i < commands.length; i++) {
var li = createTiddlyElement(popup, "li", null);
var oldCommand = commands[i];
var command = oldCommand.cloneNode(true);
command.onclick = oldCommand.onclick;
li.appendChild(command);
}
Popup.show();
}
ev.cancelBubble = true;
if(ev.stopPropagation) {
ev.stopPropagation();
}
return false;
};

})(jQuery);
//}}}
/***
|''Name''|TiddlySpaceSearcher|
|''Version''|0.2.5|
|''Requires''|TiddlySpaceConfig TiddlySpaceFollowingPlugin|
***/
//{{{
(function() { var tiddlyspace = config.extensions.tiddlyspace; var tsScan = config.macros.tsScan; config.shadowTiddlers.SearchTemplate = "<<view server.bag SiteIcon label:no width:24 height:24 preserveAspectRatio:yes>> <<view server.bag spaceLink title external:no>> in space <<view server.bag spaceLink>>"; config.shadowTiddlers.StyleSheetSearch = [".resultsArea .siteIcon { display: inline; }", ".searchForm {text-align: left;}"].join("\n"); store.addNotification("StyleSheetSearch", refreshStyles); var search = config.macros.tsSearch = { locale: { advanced: "Advanced Options", header: "Search", resultsHeader: "Results (%0)", find: "find", noResults: "No tiddlers matched your search query", query: "QUERY: ", error: "please provide a search query or a tag, modifier or title!", titleAdvanced: "where the title is", modifierAdvanced: "where the last modifier is", spaceAdvanced: "only in the space: ", notspaceAdvanced: "but not in the spaces: ", tagsAdvanced: "with the tags: " }, andConstructor: function(container, label, fieldname, negationMode) { var tags =("
").appendTo(container);
$('').text(label).appendTo(tags); var id = "area" + Math.random(); container =$("").attr("id", id).appendTo(tags)[0];
var el = $('<input type="text" />').attr("field", fieldname).appendTo(container); if(negationMode) { el.attr("negation", "true"); } } add(container); var el =$("<button />").text("AND").click(function(ev) {
add($(ev.target).data("container")); ev.preventDefault(); }).appendTo(tags);$(el).data("container", container);
},
fieldConstructor: function(container, label, field) {
container = $("
").appendTo(container)[0];$("").text(label).appendTo(container);
$("<input />").attr("text", "input").attr("field", field).appendTo(container); }, advancedOptions: function(form) { var locale = search.locale; var container =$("
").addClass("tsAdvancedOptions").appendTo(form)[0];
$("
").text(search.locale.advanced).appendTo(container);$("
").addClass("separator").appendTo(container);
},
constructSearchQuery: function(form) {
var data = [], select = [];
var query = $("[name=q]", form).val(); if(query) { data.push("q=%0".format(query)); } // add tags, fields etc..$("[field]", form).each(function(i, el) {
var val = $(el).val(); var name =$(el).attr("field");
var negate = $(el).attr("negation") == "true"; if(val && name) { val = encodeURIComponent(val); val = negate ? "!" + val : val; if(name == "space") { val += "_public"; name = "bag"; } if(negate) { select.push("select=%0:%1".format(name,val)); } else { var prefix = data.length === 0 ? "q=" : ""; data.push('%0%1:"%2"'.format(prefix, name, val)); } } }); var dataString = data.join(" "); if(dataString.length === 0 && !query) { return false; } var selectStatement = select.join("&"); if(dataString.length > 0 && selectStatement.length > 0) { dataString += "&"; } dataString += selectStatement; return "/search?%0".format(dataString); }, constructForm: function(place) { var locale = search.locale;$("
").text(locale.header).appendTo(place);
var form = $("<form />").appendTo(place)[0];$('<input type="text" name="q" />').appendTo(form);
$('<input type="submit" />').val(locale.find).appendTo(form); search.advancedOptions(form); var query =$('
').appendTo(place)[0];
var results = $("
").appendTo(place).addClass("resultsArea")[0]; var lookup = function(url) { if(!url) { results.empty().addClass("error").text(locale.error); return; } config.extensions.tiddlyweb.getStatus(function(status) {$(query).text(locale.query);
var href = status.server_host.url + url;
$("").attr("href", href).text(href).appendTo(query); tsScan.scan(results, { url: url, emptyMessage: search.locale.noResults, cache: true, template: "SearchTemplate", sort: "title", callback: function(tiddlers) {$("
").text(locale.resultsHeader.format(tiddlers.length)).prependTo(results);
}
});
});
};
$(form).submit(function(ev) { ev.preventDefault(); var url = search.constructSearchQuery(form); config.macros.tsSearch.lastSearch = url; lookup(url); }); if(search.lastSearch) { lookup(search.lastSearch); } return form; }, handler: function(place) { var container =$("
").addClass("searchForm").appendTo(place)[0];
search.constructForm(container);
}
};

})(jQuery);
//}}}

A strategy for Player I is a function that takes any game position where it is Player I's move and gives a legal move for Player I. (It is easy to formulate this in terms of finite paths on trees, but I won't bother to do so here.) A //quasistrategy// is like a strategy, except that it does not have to yield a unique move. One can think of it as a multivalued function that takes each position where it is Player I's move to at least one legal move. A quasistrategy is //winning// if Player I is guaranteed to win if whenever it is her turn she chooses one of the moves that the quasistrategy allows.

A similar definition applies to quasistrategies for Player II.

![[A sitemap for this notebook|A sitemap for the P versus NP notebook]]

Throughout the discussion of this problem, on this and all subsidiary pages, I shall speak loosely about single positive integers $$n$$, when to be more formal I would need to speak about sequences. For example, I will be happy to say, "Let $$n$$ be a positive integer," and later, "$$m$$ is bounded above by a polynomial in $$n$$," when what I actually mean is that for every $$n$$, or at least for infinitely many $$n$$, we can find an $$m$$ bounded above by $$p(n)$$, where $$p$$ is a polynomial that does not depend on $$n$$.

!Definitions of P and NP

[[The complexity class P|http://en.wikipedia.org/wiki/P_(complexity)]] consists of all functions $$f:\{0,1\}^n\to\{0,1\}$$ that can be computed in a time that is at most polynomial in $$n$$.

[[The complexity class NP|http://en.wikipedia.org/wiki/NP_(complexity)]] consists of all functions of the following kind. Let $$n$$ be a positive integer, let $$m$$ be bounded above by a polynomial in $$n$$ and let $$g:\{0,1\}^n\times\{0,1\}^m\to\{0,1\}$$ be a Boolean function computable in polynomial time. Now define $$f:\{0,1\}^n\to\{0,1\}$$ by taking $$f(x)$$ to be 1 if there exists $$y\in\{0,1\}^m$$ such that $$g(x,y)=1$$ and 0 otherwise.

One way of thinking about functions in NP is that $$f(x)=1$$ if and only if there is some "witness" $$y$$ that tells us so, and that for any given $$y$$ it is straightforward to check whether it is a witness. For example, the function defined on graphs with $$r$$ labelled vertices that takes the value 1 if and only if the graph contains a clique of size $$s$$ is in NP, since if you are given a collection of $$s$$ vertices, it is straightforward to check whether it spans a clique.

!The problem

Trivially every function in P is also in NP. The P versus NP problem is the question of whether every function in NP is in P. There is no obvious reason to suppose that this should be the case, and most people believe that it isn't.

It is one thing to find an algorithm for doing something and to prove that it runs in polynomial time. But how does one show that a polynomial-time algorithm //doesn't// exist? This feels hard, because it is asking us to consider the rather bizarre and unmathematical set of all polynomial-time algorithms.

Fortunately, there is a way round this initial difficulty, which is to look at a more obviously mathematical question about [[circuit complexity|http://en.wikipedia.org/wiki/Circuit_complexity]], so let's look into that.  [[GeneralizeQuestion|Do NP functions have polynomial circuit complexity?]]

!!Parent page

We are trying to establish [[whether there are any interesting efficient Ramsey lifts|Are there some interesting examples of efficient Ramsey lifts?]].

!Introduction

There is some choice about what "simplifies" means. I'm going to go for a special case and ask whether one can lift a non-basic set to a basic set with only a small increase in alphabet size. So far we have shown (for general $$n$$) that [[we cannot do this if the lift is trivial|Can a trivial lift lift a non-basic set to a basic set?]].

!What is the simplest case to try?

I'd like to try something that isn't quite what I've said above: to lift a basic set defined by a restriction on the second coordinate to a basic set defined by a restriction on the first coordinate. For now, then, let $$X\subset\Gamma^2$$ be arbitrary and let $$\Delta_1\subset\Gamma$$ also be arbitrary. Let $$A$$ be the set $$\{x\in X:x_1\in\Delta_1\}$$. We would like to find a complexity structure $$Y\subset\Theta^2$$ and a Ramsey lift $$\pi:Y\to X$$ such that $$\pi^{-1}(A)$$ is of the form $$\{y\in Y:y_2\in\Omega_2\}$$.

Let $$\Gamma_1$$ be the set of all $$\gamma\in\Gamma$$ such that there exists $$\gamma'\in\Gamma$$ with $$(\gamma,\gamma')\in X$$ and let $$\Theta_1\subset\Theta$$ be defined similarly. Let $$\pi:Y\to X$$ be given by the formula $$\pi(y_1,y_2)=(\phi(y_1),\phi(y_2))$$. One of the Ramsey conditions is that $$\Gamma_1\subset\phi(\Theta_1)$$. This is the condition that ensures that """II-winning""" sets map to """II-winning""" sets. The other is that for every $$\theta\in\Theta$$ we have $$N(\phi(\theta))\subset\phi(N(\theta))$$, where the neighbourhood $$N(\gamma)$$ in $$X\subset\Gamma^2$$ of some $$\gamma\in\Gamma$$ is defined to be the set of all $$\gamma'\in\Gamma$$ such that $$(\gamma,\gamma')\in X$$.

Specializing the main (inefficient) example we know already to the case $$n=2$$ gives us this. We take $$Y$$ to be the set of all sequences of the form $$(\gamma,(\gamma,\gamma'))$$ such that $$(\gamma,\gamma')\in X$$, with $$\pi(\gamma,(\gamma,\gamma'))=(\gamma,\gamma')$$. Thus, I'm taking $$Y$$ to be a subset of $$\Theta_1\times\Theta_2$$, where $$\Theta_1=\Gamma$$ and $$\Theta_2=\Gamma^2$$.

Let me check the Ramsey property. First of all, for every $$\gamma\in\Theta_1$$ we have $$N(\phi(\gamma))=\phi(N(\gamma))=\{\gamma':(\gamma,\gamma')\in X\}$$. And secondly, $$\Gamma_1=\Theta_1=\{\gamma\in\Gamma:\exists\gamma'\ (\gamma,\gamma')\in X\}$$.

!Can we do better?

That's the main question here. The trouble with the example just given is that $$|\Theta_2|=|\Gamma|^2$$, so $$|\Theta_2|/|\Gamma|$$ is unbounded.

!Can we describe a general Ramsey lift?

I think we quite possibly can. I think we need a set $$\Theta_1$$ and a surjection $$\phi:\Theta_1\to\Gamma_1$$. Then for every $$\theta\in\Theta_1$$ we define a set $$S(\theta)$$ and a surjection $$\beta_\theta:S(\theta)\to N(\phi(\theta))$$. We do this in such a way that the sets $$S(\theta)$$ are disjoint.

Now we identify elements of $$\bigcup_{\theta\in\Theta_1}S(\theta)$$. We are allowed to identify $$\alpha_1\in S(\theta_1)$$ with $$\alpha_2\in S(\theta_2)$$ if $$\beta_{\theta_1}(\alpha_1)=\beta_{\theta_2}(\alpha_2)$$.

The question now is how much identification we can manage to do, bearing in mind that we want to be able to tell from the second coordinate whether the first coordinate belongs to $$\Delta_1$$ or not.

Suppose we identify $$\alpha_1\in S(\theta)$$ with $$\alpha_2\in S(\theta')$$, where $$\theta\in \Delta_1$$ and $$\theta'\notin\Delta_1$$. Let us write $$\alpha$$ for the identified element.

We now have a problem. If we know that $$y_2=\alpha$$, then $$\phi(y_1)$$ could equal $$\theta$$ and it could equal $$\theta'$$. So we do not know whether $$y\in\pi^{-1}(A)$$.

However, it seems that if $$\theta$$ and $$\theta'$$ both belong to $$\Delta_1$$ or both do not belong to $$\Delta_1$$, then we are OK. So that suggests that there should be a very simple example of a Ramsey lift that does what we want.

!Attempt at an example

How about if we take $$Y$$ to be the set of all pairs $$(\gamma,(\gamma',\eta))$$, where $$(\gamma,\gamma')\in X$$ and $$\eta=1$$ if $$\gamma\in\Delta_1$$ and $$\eta=0$$ otherwise? Does this work? Yes it does, because $$\eta$$ is completely irrelevant to the game.

Let me check that carefully. A subset $$W$$ of $$Y$$ is """I-winning""" if there is some $$\gamma\in\Gamma$$ such that every $$(\gamma',\eta)$$ such that $$(\gamma,(\gamma',\eta))\in Y$$ belongs to $$W$$. But then for every $$\gamma'$$ such that $$(\gamma,\gamma')\in X$$ belongs to $$X$$ we have $$(\gamma,\gamma')\in\pi(W)$$, so $$\pi(W)$$ is """I-winning""".

A subset $$W$$ of $$Y$$ is """II-winning""" if for every $$\gamma\in\Gamma$$ we can find $$(\gamma',\eta)$$ such that $$(\gamma,(\gamma',\eta))\in W$$. But if that holds, then for every $$\gamma\in\Gamma$$ we can find $$\gamma'$$ such that $$(\gamma,\gamma')\in\pi(W)$$, so $$\pi(W)$$ is """II-winning""".

!What can we conclude from that example?

Suppose that we want a Ramsey lift that simultaneously converts a whole lot of sets of the form $$\{x\in X:x_1\in\Delta\}$$ into sets of the form $$\{y\in Y:y_2\in\Omega\}$$. Let the sets be $$\{x\in X:x_1\in\Delta_j\}$$ for $$j=1,2,\dots,m$$. Then we cannot identify $$\alpha_1\in S(\theta)$$ with $$\alpha_2\in S(\theta')$$ unless for every $$j$$ either both $$\theta$$ and $$\theta'$$ belong to $$\Delta_j$$ or they both do not belong to $$\Delta_j$$.

I think this tells us that the best we can do is take $$Y$$ to be the set of all pairs $$(\gamma,(\gamma',\eta))$$, where $$(\gamma,\gamma')\in X$$ and $$\eta$$ is a subset of $$\{1,2,\dots,m\}$$ that tells you which of the $$\Delta_j$$ the element $$\gamma$$ belongs to. (Note that the number of distinct such subsets is at most $$|\Gamma|$$.)

This appears to show that if $$A$$ has circuit complexity at most $$m$$, then we can lift $$A$$ to a set of the form $$\{y\in Y:y_2\in\Omega\}$$ with $$|\Theta|/|\Gamma|\leq 2^m$$.

In fact, I think it shows the following. Let $$A$$ be a subset of $$X$$. Define $$\gamma_1$$ and $$\gamma_2$$ to be equivalent if the sets $$\{\gamma':(\gamma_1,\gamma')\in A\}$$ and $$\{\gamma':(\gamma_2,\gamma')\in A\}$$ are the same. Then I think that to convert $$A$$ into a basic set we need to multiply the alphabet by the number of equivalence classes. Certainly, this is an upper bound, since we can express $$A$$ as a Boolean combination of products of intersections of basic sets, where each basic set based on the first coordinate is an equivalence class. Then we can turn those into basic sets based on the second coordinate.

!What next?

The real moral of this page is that the case $$n=2$$ is probably too simple to be informative. The reason for that is as follows. Suppose we think of the lifted game in terms of extra information. That is, Player I begins with a move of the form $$y_1=(\gamma_1,u)$$ and Player II responds with a move of the form $$y_2=(\gamma_2,v)$$, with only certain pairs $$((\gamma_1,u),(\gamma_2,v))$$ belonging to $$Y$$. If there exists a pair $$(\gamma_1,u)$$ such that $$(\gamma_1,\gamma_2)\in X$$ but for no $$v$$ does $$((\gamma_1,u),(\gamma_2,v))$$ belong to $$Y$$, then the set of all $$(\gamma_1,\gamma_2)$$ such that there exists $$v$$ with $$((\gamma_1,u),(\gamma_2,v))\in Y$$ is a winning set for Player I in $$Y$$ (the first move of a winning strategy being $$y_1=(\gamma_1,u)$$) but its image is not a winning set for Player I in $$X$$ (since Player II can respond to $$x_1=\gamma_1$$ by playing a $$\gamma_2$$ such that $$(\gamma_1,\gamma_2)$$ does not lift to $$Y$$).

What this basically says is that Player I can't provide any non-trivial extra information.

As for Player II, he can provide extra information, but //it can only describe the past//. Since Player II only has one move, and that is the last move of the game, he can't use his extra information to restrict the projection of the game to $$X$$. So he can provide whatever information he likes about what Player I has done and it will not affect who wins what.

Therefore, the subtleties of balancing the extra information provided by Player I with the extra information provided by Player II in such a way that nobody gains an advantage are entirely absent when $$n=2$$. So it looks as though we may be forced to go up to $$n=4$$, where the game will already be complicated to analyse.

[[Return to parent page|Are there some interesting examples of efficient Ramsey lifts?]]
Click the "new tiddler" button towards the top right of the screen to write something in your space. You'll need to give it a title, some content and, optionally, some tags that will help you identify it later.

!Stuck for ideas?
Not sure what to write about? Not sure what to keep in your space? Other people use ~TiddlySpace for almost anything. How about some of the following:

* [[Save interesting sites|http://bookmarks.tiddlyspace.com]], images or articles from around the web so that you can refer back to them.
* [[Record your family tree|http://familytree.tiddlyspace.com]], store notes on long lost relatives or ancestors and map their relationship to you.
* [[Make up a pocketbook|http://pocketbook.tiddlyspace.com]] to store some useful information in, then print it out, [[fold it up|http://www.pocketmod.com/]], and take it with you.
* [[Plan your holiday|http://the-web-is-your-oyster.tiddlyspace.com/]], record where you're planning to go, note down places of interest and refer back to it later.
* [[Create a mindmap|http://mindmaps.tiddlyspace.com/]] to visualise your inner thoughts and see how they relate to each other.
* [[Set up a questionnaire|http://questionnaire.tiddlyspace.com/]] and get all your friends to answer it.

If you don't like any of those ideas, you can still use this space directly to keep notes and link them together, make a todo list and keep track of everything you're doing, or any one of a hundred million other things.

Still stuck? Check out the @featured space for more suggestions.

You can also [[socialise with others|How to socialise]].

The following definition can be found in [[the primer on Martin's theorem|A brief primer on Martin's Borel determinacy theorem]].

Let $$T$$ be a pruned tree. A //lift// of the game defined by $$T$$ is a pruned tree $$T'$$ together with a map $$\pi:T'\to T$$ and a map $$\psi$$ that takes strategies for $$T'$$ to strategies for $$T$$, with the following properties.
*$$\pi$$ is a homomorphism of rooted trees. That is, $$\pi$$ takes the root of $$T'$$ to the root of $$T$$, and if $$y$$ is a successor of $$x$$ in $$T'$$, then $$\pi(y)$$ is a successor of $$\pi(x)$$ in $$T$$.
*For every $$s\in[T']$$ and every $$n\in\mathbb{N}$$, the first $$n$$ terms of $$\pi(s)$$ depend only on the first $$n$$ terms of $$s$$.
*If $$\sigma$$ is a strategy for $$T'$$, then every infinite path consistent with $$\psi(\sigma)$$ is the image under $$\pi$$ of at least one infinite path consistent with $$\sigma$$.
When we lift a game as above, we define the payoff set of the new game to be the obvious thing, namely $$\pi^{-1}(A)$$, where $$A$$ is the payoff set of the game played on $$T$$.

tags

/***
|''Name''|TiddlySpaceFilters|
|''Description''|provide TiddlySpace-specific filter extensions|
|''Author''|Jon Robson|
|''Version''|0.6.1|
|''Status''|@@beta@@|
|''CoreVersion''|2.6.2|
|''Requires''|TiddlySpaceConfig|
!Usage
{{{
<<tsList Private>>
<<tsList Public>>
<<tsList Draft>>
}}}
!Code
***/
//{{{
(function($) { var tiddlyspace = config.extensions.tiddlyspace; var privateBag = tiddlyspace.getCurrentBag("private"); var publicBag = tiddlyspace.getCurrentBag("public"); config.filterHelpers = { is: { "private": function(tiddler) { var bag = tiddler.fields["server.bag"]; return bag == privateBag; }, "public": function(tiddler) { var bag = tiddler.fields["server.bag"]; return bag == publicBag; }, draft: function(tiddler) { var fields = tiddler.fields; var bag = fields["server.bag"]; return (privateBag == bag && fields["publish.name"]) ? true : false; }, local: function(tiddler) { return config.filterHelpers.is["public"](tiddler) || config.filterHelpers.is["private"](tiddler); }, unsynced: function(tiddler) { return tiddler ? tiddler.isTouched() : false; } } }; config.filters.is = function(results, match) { var candidates = store.getTiddlers("title"); var type = match[3]; for (var i = 0; i < candidates.length; i++) { var tiddler = candidates[i]; var helper = config.filterHelpers.is[type]; if(helper && helper(tiddler)) { results.pushUnique(tiddler); } } return results; }; })(jQuery); //}}} <svg xmlns="http://www.w3.org/2000/svg" xmlns:xl="http://www.w3.org/1999/xlink" version="1.1" viewBox="450 366 38 57" width="30" height="30"> <g stroke="none" stroke-opacity="1" stroke-dasharray="none" fill="none" fill-opacity="1"> <g> <path d="M 452.1094 421.2422 L 450 421.2422 L 450 423 L 487.9688 423 L 487.9688 421.2422 L 485.8595 421.2422 L 485.8595 377.29688 L 487.9688 377.29688 L 487.9688 375.53906 L 485.8595 375.53906 C 485.8595 375.53906 481.12463 371.59341 473.02023 370.52802 C 472.6824 368.9689 471.72098 366.75 468.9844 366.75 C 466.24783 366.75 465.28638 368.9689 464.94864 370.52802 C 456.84418 371.59341 452.1094 375.53906 452.1094 375.53906 L 450 375.53906 L 450 377.29688 L 452.1094 377.29688 Z M 467.12247 370.32086 L 467.12247 370.32086 C 467.3805 369.42395 467.90762 368.50781 468.9844 368.50781 C 470.0612 368.50781 470.5883 369.42395 470.84634 370.32086 C 470.24136 370.2848 469.62054 370.26562 468.9844 370.26562 C 468.34827 370.26562 467.72748 370.2848 467.12247 370.32086 Z M 454.21875 420.92804 L 454.21875 420.92804 C 455.46762 420.42087 456.32816 419.35281 456.32816 418.11716 L 456.32816 377.29688 L 458.4375 377.29688 L 458.4375 421.2422 L 454.21875 421.2422 Z M 460.5469 420.92804 L 460.5469 420.92804 C 461.79578 420.42087 462.65625 419.35281 462.65625 418.11716 L 462.65625 377.29688 L 464.76566 377.29688 L 464.76566 421.2422 L 460.5469 421.2422 Z M 466.87503 420.92804 L 466.87503 420.92804 C 468.1239 420.42087 468.9844 419.35281 468.9844 418.11716 L 468.9844 377.29688 L 471.09378 377.29688 L 471.09378 421.2422 L 466.87503 421.2422 Z M 473.2032 420.92804 L 473.2032 420.92804 C 474.45203 420.42087 475.31256 419.35281 475.31256 418.11716 L 475.31256 377.29688 L 477.4219 377.29688 L 477.4219 421.2422 L 473.2032 421.2422 Z M 479.5313 420.92804 L 479.5313 420.92804 C 480.78018 420.42087 481.64066 419.35281 481.64066 418.11716 L 481.64066 377.29688 L 483.75006 377.29688 L 483.75006 421.2422 L 479.5313 421.2422 Z" fill="black" class="glyph"/> </g> </g> </svg> !!Parent page We are trying to establish [[whether all non-trivial Ramsey lifts must use large alphabets|Must all non-trivial Ramsey lifts use large alphabets?]]. When $$n=2$$ [[the answer is no|Must all non-trivial Ramsey lifts use large alphabets when n=2?]]. /*** |''Name''|RandomColorPalettePlugin| |''Description''|Adds a random color palette to TiddlyWiki| |''Author''|Jon Robson| |''Version''|1.4.0| |''Status''|stable| |''Source''|https://github.com/jdlrobson/TiddlyWikiPlugins/raw/master/plugins/RandomColorPalettePlugin/RandomColorPalettePlugin.js| |''License''|[[BSD|http://www.opensource.org/licenses/bsd-license.php]]| !Usage {{{ <<RandomColorPalette>> }}} Sets and saves a random color palette on execution {{{ <<RandomColorPaletteButton>> }}} Creates a button, which when clicked will change the color palette More information at http://macros.tiddlyspace.com/#%5B%5BRandomColorPaletteButton%20macro%5D%5D !Code ***/ //{{{ RGB.prototype.toRGBString = function() { return "rgb(%0,%1,%2)".format(parseInt(this.r * 255, 10), parseInt(this.g * 255, 10), parseInt(this.b * 255, 10)) } function HSL_TO_RGB(h, s, l) { // h (hue) between 0 and 360, s (saturation) & l (lightness) between 0 and 1 var c = l <= 0.5 ? 2 * l * s : ( 2 - (2 * l)) * s; var h1 = h / 60; var x = c * (1 - Math.abs((h1 % 2) - 1)); var r, g, b; if(typeof(h) == 'undefined') { r = 0; g = 0; b = 0; } else if(0 <= h1 && h1 < 1) { r = c; g = x; b = 0; } else if(1 <= h1 && h1 < 2) { r = x; g = c; b = 0; } else if(2 <= h1 && h1 < 3) { r = 0; g = c; b = x; } else if(3 <= h1 && h1 < 4) { r = 0; g = x; b = c; } else if(4 <= h1 && h1 < 5) { r = x; g = 0; b = c; } else if(5 <= h1 && h1 < 6) { r = c; g = 0; b = x; } m = l - (0.5 * c); return new RGB(r + m, g + m, b + m); } (function($){
var macro = config.macros.RandomColorPalette = {
messagesOn: false,
changedPaletteText: "We have assigned you a random theme by adjusting the [[ColorPalette]] tiddler.\nDon't like it? Click <<RandomColorPalette>> for another one.",
handler: function(place, macroName, params, wikifier, paramString, tiddler) {
paramString = paramString || "";
var options = macro.getOptions(paramString);
macro.generatePalette(options, true);
},
optionTypes: {
floats: ["hue", "saturation", "darkest", "lightness", "huevariance", "dark", "pale", "light", "mid",
"saturation_light", "saturation_pale", "saturation_mid", "saturation_dark"
]
},
getOptions: function(paramString) {
var args = paramString.parseParams("name", null, true, false, true)[0];
var options = {};
var numbers = macro.optionTypes.floats;
for(var i in args) {
options[i] = numbers.indexOf(i) > -1 ? parseFloat(args[i][0], 10) : args[i][0];
}
return options;
},
generateRandomNumber: function(min, max, info) {
var num = (Math.random() * 1);
info = !info ? { attempts:0 } : info;
info.attempts += 1;
var good = true;
if(min == max) {
return max;
}
if(min && num < min) {
good = false;
} else if(max && num > max) {
good = false;
}
if(!good) {
if(info.attempts < 5) {
return macro.generateRandomNumber(min, max, info);
} else {
if(max) {
return max;
} else if(min) {
return min;
} else {
return 1;
}
}
}
return num;
},
getExistingPalette: function(asJSON) {
var title = "ColorPalette";
var tiddlerText;
if(store.tiddlerExists(title)) {
tiddlerText = store.getTiddlerText(title);
}
if(asJSON) {
var json = {};
if(tiddlerText) {
var lines = tiddlerText.split("\n");
for(var i = 0; i < lines.length; i++) {
var definition = lines[i].split(":");
if(definition.length == 2) {
var name = definition[0].trim();
var value = definition[1].trim();
json[name] = value;
}
}
}
return json;
} else {
return tiddlerText;
}
},
generatePalette: function(options, save) {
var outputRGB = options.rgb;
var palette = macro.getExistingPalette(true);
var hue = options.hue || Math.floor(Math.random() * 359);
var saturation = options.saturation || macro.generateRandomNumber(0.3, 0.7);
var dark = options.dark || options.darkest || macro.generateRandomNumber(0, 0.10);
var pale = options.pale || options.lightness || macro.generateRandomNumber(0.90, 1);
var delta = ( ( pale - dark ) / 3 );
var mid = options.mid || dark + delta;
var light = options.light || dark + (delta * 2);
var lightness_values = {Dark: dark, Mid: mid, Light: light, Pale: pale};
var saturation_values = {};
for(i in lightness_values) {
if(true) {
saturation_values[i] = options["saturation_" + i.toLowerCase()] || saturation;
}
}

var opposite_hue = (hue + 180) % 360;
var seed = options.huevariance || Math.floor((85 * Math.random()) + 5); // we want it to be at least 5 degrees
var huetwo = (opposite_hue + seed) % 360;
var huethree = (opposite_hue - seed) % 360;
if(huetwo < 0) {
huetwo = 360 + huetwo;
}
if(huethree < 0) {
huethree = 360 + huethree;
}
for(var j in lightness_values) {
if(true) {
var saturation = saturation_values[j];
palette["Primary" + j] = HSL_TO_RGB(hue, saturation, lightness_values[j]);
palette["Secondary" + j] = HSL_TO_RGB(huetwo, saturation, lightness_values[j]);
palette["Tertiary" + j] = HSL_TO_RGB(huethree, saturation, lightness_values[j]);
}
}
palette.Background = HSL_TO_RGB(hue, saturation, 0.92);
palette.Foreground = HSL_TO_RGB(hue, saturation, 0.08);
palette.ColorPaletteParameters = ["HSL([", hue, "|", seed, "], [", saturation_values.Pale, "|",
saturation_values.Light, "|", saturation_values.Mid, "|", saturation_values.Dark, "],",
"[", dark, "|", mid, "|", light, "|", pale, "])"].join("");
// construct new ColorPalette
var text = ["/*{{{*/\n"];
var colorcode;
for(var id in palette) {
if(true) {
var color = palette[id];
colorcode = outputRGB ? color.toRGBString() : color.toString();
text.push("%0: %1\n".format(id, colorcode));
}
}
text.push("/*}}}*/");
text = text.join("");
if(save) {
macro.saveColorPalette(text);
}
return text;
},
saveColorPalette: function(text) {
var tid = store.getTiddler("ColorPalette");
if(!tid) {
tid = new Tiddler("ColorPalette");
tid.fields = merge({}, config.defaultCustomFields);
} // TODO: detect that the ColorPalette in the space comes from outside recipe
tid.fields["server.page.revision"] = "false"; // edit conflicts dont matter

// save the color palette in tid
tid = store.saveTiddler(tid.title, tid.title, text, tid.modifier, tid.modified,
tid.tags, tid.fields, false, tid.created, tid.creator);
// an interval is used to cope with users clicking on the palette button quickly.
if(macro._nextSave) {
window.clearTimeout(macro._nextSave);
}
macro._nextSave = window.setTimeout(function() {
autoSaveChanges(null, [tid]);
}, 2000);
// temporary workaround for IE.
$.twStylesheet.remove({ id: "StyleSheetColors" });$.twStylesheet.remove({ id: "StyleSheet" });
refreshAll();
macro.reportChange();
return tid;
},
reportChange: function() {
if(macro.messagesOn) { // only display message once..
var msgPlace = getMessageDiv();
if(!$(".changedPalette", msgPlace)[0]) { var tempPlace = document.createElement("div"); wikify("{{changedPalette{" + macro.changedPaletteText + "}}}", tempPlace); msgPlace.appendChild(tempPlace); } } } }; var btnMacro = config.macros.RandomColorPaletteButton = { text: "New ColorPalette", tooltip: "Generate a random colour scheme for your TiddlyWiki", makeButton: function(place, options) { var btnHandler = function(ev) { var t =$(ev.target);
var options = t.data("options");
macro.generatePalette(options, true);
ev.preventDefault();
return false;
};
var btn = createTiddlyButton(place, this.text, this.tooltip, btnHandler);
$(btn).data("options", options); return btn; }, handler: function(place, macroName, params, wikifier, paramString, tiddler) { var options = macro.getOptions(paramString); btnMacro.makeButton(place, options); } }; })(jQuery); //}}} !!Parent page We are trying to pin down [[what it is that would make a consequence of low circuit complexity count as "interesting"|What counts as an "interesting" consequence of low circuit complexity?]] and not something that is just as hard to use as low circuit complexity itself. !Introduction I have been wondering whether every NP property that is implied by low circuit complexity needs to use a concept that is sufficiently close to the idea of low circuit complexity that it counts as in some sense a "trivial" consequence. It occurred to me, however, that one might be able to weaken this question and obtain something that is potentially easier to prove, but still useful. It is to ask whether every NP property that we can //prove// is implied by low circuit complexity is trivial in this sense. What I am asking in this page is whether that really is a different question, and whether, if so, it is the right question. !An argument that it is a different question Suppose we express the set of low-complexity functions in the form $$\{f:\exists A\ P(f,A)\}$$ for a suitable structure $$A$$ and a suitable checking function $$P$$. Then one way of obtaining sets that contain this set is to replace $$P$$ by other properties that are implied $$P$$. So let us ask the following question: could there be two polynomial-time Boolean functions $$P$$ and $$Q$$ such that $$P\leq Q$$, but it is very hard to prove that $$P\leq Q$$? If we now specialize this to the case $$Q\equiv 0$$, then we are asking whether there could be a polynomial-time Boolean function that equals the zero function but that it is very hard to prove equals the zero function. But that appears to be the case. For example, take a graph with $$n$$ vertices and let $$P$$ be a function of its subsets of $$m$$ vertices, which takes the value 1 when the subset spans a clique and 0 otherwise. If we can decide whether $$P$$ is identically zero, then we can decide whether the graph contains a clique of size $$m$$. I'm not 100% sure that that observation answers the question I asked, but it's good enough to make me want to consider the distinction as a genuine one for now. [[Return to parent page|What counts as an "interesting" consequence of low circuit complexity?]] <svg xmlns="http://www.w3.org/2000/svg" xmlns:xl="http://www.w3.org/1999/xlink" version="1.1" viewBox="78 222 60 60" width="30" height="30"> <g stroke="none" stroke-opacity="1" stroke-dasharray="none" fill="none" fill-opacity="1"> <g> <path d="M 107.92718 244.14815 L 86.651474 222.89253 L 78.85206 230.69925 L 100.120415 251.9476 L 78.774 273.27396 L 86.57342 281.08075 L 107.927216 259.74707 L 129.39981 281.19946 L 137.19922 273.39267 L 115.73397 251.94763 L 137.121155 230.58054 L 129.32175 222.77374 Z" fill="black" class="glyph"/> </g> </g> </svg> /*** |''Name''|TiddlyWebConfig| |''Description''|configuration settings for TiddlyWebWiki| |''Author''|FND| |''Version''|1.3.2| |''Status''|stable| |''Source''|http://svn.tiddlywiki.org/Trunk/association/plugins/TiddlyWebConfig.js| |''License''|[[BSD|http://www.opensource.org/licenses/bsd-license.php]]| |''Requires''|TiddlyWebAdaptor ServerSideSavingPlugin| |''Keywords''|serverSide TiddlyWeb| !Code ***/ //{{{ (function($) {

if(!config.extensions.ServerSideSavingPlugin) {
throw "Missing dependency: ServerSideSavingPlugin";
}
}

if(window.location.protocol != "file:") {
config.options.chkAutoSave = true;
}

var recipe = tiddler.fields["server.recipe"];
var workspace = recipe ? "recipes/" + recipe : "bags/common";

var plugin = config.extensions.tiddlyweb = {
host: tiddler.fields["server.host"].replace(/\/$/, ""), username: null, status: {}, getStatus: null, // assigned later getUserInfo: function(callback) { this.getStatus(function(status) { callback({ name: plugin.username, anon: plugin.username ? plugin.username == "GUEST" : true }); }); }, hasPermission: function(type, tiddler) { var perms = tiddler.fields["server.permissions"]; if(perms) { return perms.split(", ").contains(type); } else { return true; } } }; config.defaultCustomFields = { "server.type": tiddler.getServerType(), "server.host": plugin.host, "server.workspace": workspace }; // modify toolbar commands config.shadowTiddlers.ToolbarCommands = config.shadowTiddlers.ToolbarCommands. replace("syncing ", "revisions syncing "); config.commands.saveTiddler.isEnabled = function(tiddler) { return plugin.hasPermission("write", tiddler) && !tiddler.isReadOnly(); }; config.commands.deleteTiddler.isEnabled = function(tiddler) { return !readOnly && plugin.hasPermission("delete", tiddler); }; // hijack option macro to disable username editing var _optionMacro = config.macros.option.handler; config.macros.option.handler = function(place, macroName, params, wikifier, paramString) { if(params[0] == "txtUserName") { params[0] = "options." + params[0]; var self = this; var args = arguments; args[0] =$("").appendTo(place)[0];
plugin.getUserInfo(function(user) {
config.macros.message.handler.apply(self, args);
});
} else {
_optionMacro.apply(this, arguments);
}
};

// hijack isReadOnly to take into account permissions and content type
!plugin.hasPermission("write", this);
};

var getStatus = function(callback) {
if(plugin.status.version) {
callback(plugin.status);
} else {
var self = getStatus;
if(self.pending) {
if(callback) {
self.queue.push(callback);
}
} else {
self.pending = true;
self.queue = callback ? [callback] : [];
var _callback = function(context, userParams) {
var status = context.serverStatus || {};
for(var key in status) {
} else {
plugin.status[key] = status[key];
}
}
for(var i = 0; i < self.queue.length; i++) {
self.queue[i](plugin.status);
}
delete self.queue;
delete self.pending;
};
adaptor.getStatus({ host: plugin.host }, null, _callback);
}
}
};
(plugin.getStatus = getStatus)(); // XXX: hacky (arcane combo of assignment plus execution)

})(jQuery);
//}}}
/***
|''Name''|ToggleTiddlerPrivacyPlugin|
|''Version''|0.7.1|
|''Status''|@@beta@@|
|''Description''|Allows you to set the privacy of new tiddlers and external tiddlers within an EditTemplate, and allows you to set a default privacy setting|
|''CoreVersion''|2.6.1|
|''Requires''|TiddlySpaceConfig|
|''Source''|http://github.com/TiddlySpace/tiddlyspace/raw/master/src/plugins/ToggleTiddlerPrivacyPlugin.js|
!Notes
When used in conjunction with TiddlySpaceTiddlerIconsPlugin changing the privacy setting will also interact with any privacy icons.

Currently use of
{{{<<setPrivacy defaultValue:public>>}}} is in conflict with {{{<<newTiddler fields:"server.workspace:x_private">>}}}

There is an option, found in the tweak tab of the backstage, called txtPrivacyMode. Set this to either ''public'' or ''private'' depending on your security preference. If you choose not to set it then it will default to ''public''.
!Params
defaultValue:[private|public]
Allows you to set the default privacy value (Default is private)

!Code
***/
//{{{
(function($) { var tiddlyspace = config.extensions.tiddlyspace, macro; macro = config.macros.setPrivacy = { handler: function(place, macroName, params, wikifier, paramString, tiddler) { if(readOnly) { return; } var el =$(story.findContainingTiddler(place)),
args = paramString.parseParams("name",
null, true, false, true)[0],
container = $("
"). addClass("privacySettings"). appendTo(place)[0], currentSpace = tiddlyspace.currentSpace.name, currentBag = tiddler ? tiddler.fields["server.bag"] : false, // XXX: is the following reliable? isNewTiddler = el.hasClass("missing") || !currentBag, tiddlerStatus = tiddlyspace.getTiddlerStatusType(tiddler), customFields = el.attr("tiddlyfields"), defaultValue = "public", options = config.macros.tiddlerOrigin ? config.macros.tiddlerOrigin.getOptions(paramString) : {}; customFields = customFields ? customFields.decodeHashMap() : {}; if(isNewTiddler || !["public", "private", "unsyncedPrivate", "unsyncedPublic"].contains(tiddlerStatus)) { if(args.defaultValue) { defaultValue = args.defaultValue[0].toLowerCase(); } else { defaultValue = config.options.chkPrivateMode ? "private" : "public"; } defaultValue = defaultValue ? "%0_%1".format(currentSpace, defaultValue) : customFields["server.bag"]; this.createRoundel(container, tiddler, currentSpace, defaultValue, options); } }, updateEditFields: function(tiddlerEl, bag) { var saveBagField =$('[edit="server.bag"]', tiddlerEl),
saveWorkspaceField = $('[edit="server.workspace"]', tiddlerEl), input =$("<input />").attr("type", "hidden"),
workspace = "bags/" + bag;
if(saveBagField.length === 0) {
input.clone().attr("edit", "server.bag").val(bag).
appendTo(tiddlerEl);
} else {
saveBagField.val(bag);
}
// reset to prevent side effects
$(tiddlerEl).attr("tiddlyFields", ""); if(saveWorkspaceField.length === 0) { input.clone().attr("edit", "server.workspace"). val(workspace).appendTo(tiddlerEl); } else { saveWorkspaceField.val(workspace); } }, setBag: function(tiddlerEl, newBag, options) { var bagStatus, title =$(tiddlerEl).attr("tiddler"),
tiddler = store.getTiddler(title),
originButton = $(".originButton", tiddlerEl)[0], refreshIcon, newWorkspace = "bags/" + newBag, rPrivate =$("input[type=radio].isPrivate", tiddlerEl),
rPublic = $("input[type=radio].isPublic", tiddlerEl); refreshIcon = function(type) { var originMacro = config.macros.tiddlerOrigin; if(originButton && originMacro) { options.noclick = true; originMacro.showPrivacyRoundel(tiddler, type, originButton, options); } }; macro.updateEditFields(tiddlerEl, newBag); if(tiddler) { tiddler.fields["server.bag"] = newBag; // for external tiddlers tiddler.fields["server.workspace"] = newWorkspace; } if(newBag.indexOf("_public") > -1) { rPrivate.attr("checked", false); rPublic.attr("checked", true); bagStatus = "public"; } else { rPublic.attr("checked", false); // explicitly do this for ie rPrivate.attr("checked", true); bagStatus = "private"; } refreshIcon(bagStatus); }, createRoundel: function(container, tiddler, currentSpace, defaultValue, options) { var privateBag = "%0_private".format(currentSpace), publicBag = "%0_public".format(currentSpace), rbtn =$("<input />").attr("type", "radio").
attr("name", tiddler.title),
el = story.findContainingTiddler(container);
appendTo(container);
$("").text("private").appendTo(container); // TODO: i18n rbtn.clone().val("public").addClass("isPublic") .appendTo(container);$("").text("public").appendTo(container); // TODO: i18n
$("[type=radio]", container).click(function(ev) { var btn =$(ev.target);
tiddler.fields["server.page.revision"] = "false";
if(btn.hasClass("isPrivate")) { // private button clicked.
$(el).addClass("isPrivate").removeClass("isPublic"); macro.setBag(el, privateBag, options); } else {$(el).addClass("isPublic").removeClass("isPrivate");
macro.setBag(el, publicBag, options);
}
});
window.setTimeout(function() {
macro.setBag(el, defaultValue, options);
}, 100);
// annoyingly this is needed as customFields are added to end of EditTemplate so are not present yet
// and don't seem to respect any existing customFields.
}
};

}(jQuery));
//}}}
!!Parent page

We are trying to decide [[whether the shrinking neighbourhoods game will do the job for us|Is the shrinking neighbourhoods game likely to work for our purposes?]].

!!Other highly relevant pages

Some idea of what the inductive step might be like has already been worked out [[here|Is there a realistic proposal for how an eventual proof might look?]].

On [[this page|Is there an easy Ramsey lifting that makes all sets simple?]] we have modified the definition of the shrinking neighbourhoods game and come up with a "trivial" Ramsey lifting that lifts all sets to 1-open sets. That suggests that we should take $$k=1$$ for now and change our minds only if we see a good reason to do so.

!What do we want to achieve with a simple lift?

The plan of attack is this. Let $$A_1,A_2,\dots,A_m$$ be a straight-line computation in $$\{0,1\}^n$$. For simplicity, let us organize it so that it does not use complementation. (This is a very standard thing to do: by de Morgan's laws, we can push back the complementation right to the beginning, so all we need is to make sure that all sets of the form $$\{x:x_i=\epsilon\}$$ -- in other words, all basic sets -- are amongst the $$A_j$$.)

We now want to find a succession of Ramsey lifts, each one converting a new $$A_i$$ into a set that is both 1-open and 1-closed. A composition of Ramsey lifts is a Ramsey lift, and lifts preserve 1-openness and 1-closedness, so it is a realistic aim to pick off the sets one at a time.

The inductive step will therefore be something like this. We will have a complexity structure $$X\subset\Gamma^n$$ and subsets $$A_1,A_2,\dots,A_m$$ in $$X$$ that form a straight-line computation that does not involve complementation. Let $$A_k$$ be the first of these sets that is not both 1-open and 1-closed. Let's suppose that it is not 1-open. Then there exist $$i,j<k$$ such that $$A_k=A_i\cap A_j$$. For convenience let us write $$A,B,C$$ for $$A_i,A_j,A_k$$, so $$A$$ and $$B$$ are 1-open and 1-closed, and $$A\cap B=C$$.

An intersection of 1-closed sets is 1-closed, so the only thing we have to achieve with our Ramsey lift is making $$C$$ 1-open. What's more, it is already 2-open. In other words, $$C$$ is a set of the form $$\bigcup E_i\cap F_i$$, where $$E_i$$ and $$F_i$$ are basic sets. In fact, we can say slightly more. A 1-open set is a set of the form $$\bigcup E_i$$, where the $$E_i$$ are basic. But a union of basic sets where the same coordinate is fixed is again a basic set that fixes that coordinate, so a 1-open set in fact always takes the form $$\bigcup_{i=1}^nE_i$$, where $$E_i$$ is a set of the form $$\{x\in X:x_i\in\Delta_i$$\). (Before, I was allowing $$E_i$$ to be a set that specified $$x_j$$ for some $$j\ne i$$.)

We can therefore represent our 2-open set as $$\bigcup_{ij}E_{ij}\cap F_{ij}$$, where for each $$ij$$, $$E_{ij}$$ is a basic set that restricts $$x_i$$ and $$F_{ij}$$ is a basic set that restricts $$x_j$$.

It follows that one approach to our task would be to pick off the sets $$E_{ij}\cap F_{ij}$$ one by one. That is, if for any 2-basic set we could find a Ramsey lift that turned it into a 1-basic set and multiplied the size of the alphabet by $$C$$ (with $$C$$ potentially depending on $$n$$, but I won't worry about that yet), then we would be able to convert a 2-open set into a 1-open set while multiplying the size of the alphabet by at most $$C^{n^2}$$. That would be wonderful for our purposes: it would mean that we could Ramsey lift $$A_m$$ to a 1-closed and 1-open set while multiplying the size of the alphabet by $$\exp(\alpha mn^2)$$. Since we are hoping that a random set, or better still some set in NP, needs a doubly exponential lift, this would mean that our proof attempt was on track. Of course, we would still need to show that those hopes were not in vain.

!Conclusion

We have a preliminary target: to find an economical way of Ramsey-lifting a 2-basic set to a 1-basic set. [[LookForSomethingMoreSpecific|How easy is it to lift a 2-basic set to a 1-basic set?]]

And after a thorough investigation of that idea, we have concluded that it is unlikely to be possible. If anything works, it is more likely to be something like lifting a $$k$$-closed set to a $$k$$-open set. [[LookForSomethingMoreSpecific|How easy is it to lift a "closed" set to an "open" set?]]
!SpaceUnplugged
{{unpluggedSpaceTab{
{{wizard{
<<image unsyncedIcon width:48>> Sync is currently unavailable in ~TiddlyWiki due to security constraints in modern browsers. Research is being done to build a suitable alternative. In the meantime if you have changed content in an offline ~TiddlyWiki, you can get your content back into ~TiddlySpace by using the ''import'' functionality from the backstage of the online wiki.
}}}
}}}

running TiddlySpace@glossary version <<message extensions.tiddlyweb.status.tiddlyspace_version>>
{{autotable{
<<tiddler Backstage##Resources>>
}}}

!Resources
[[blog|@@blog]] [[documentation|@@docs]] [[featured spaces|@@featured]]

!ImportExport
<<fileImport>>

{{chunkyButton{<<exportSpace>>}}}

!BackstageTiddlers
|>|<<search>>|
|>|<<tiddler Backstage##Tiddlers>>|

!Tiddlers
<<tabs
txtMainTab
"Recent" "Recently edited tiddlers" TabTimeline
"All" "All tiddlers" TabAll
"Public" "All public tiddlers" [[TiddlySpaceTabs##Public]]
"Private" "All private tiddlers" [[TiddlySpaceTabs##Private]]
"Tags" "All tags" TabTags
"Spaces" "Tiddlers grouped by space" [[TiddlySpaceTabs##Spaces]]
"Missing" "Missing tiddlers" TabMoreMissing
"Orphans" "Orphaned tiddlers" TabMoreOrphans
>>

!BatchOps
<<tabs
txtPublisherTab
"Private" "Move tiddlers from private to public" Backstage##BatchPrivate
"Public" "Move tiddlers from public to private" Backstage##BatchPublic
>>

!BatchPrivate
<<TiddlySpacePublisher type:private>>

!BatchPublic
<<TiddlySpacePublisher type:public>>

!Plugins
''Note:'' Many of these plugins are core TiddlySpace plugins and cannot be changed unless first cloned.

<<tiddler PluginManager>>

!Tweaks
These options change behavior in TiddlyWiki //only// and may be ineffective in TiddlySpace.

<<tiddler AdvancedOptions>>
/***
|''Name''|TiddlySpaceRevertRevision|
|''Description''|Revert to a previous revision|
|''Author''|BenGillies|
|''Version''|0.1|
|''Status''|unstable|
|''Source''|http://github.com/TiddlySpace/tiddlyspace|
|''CodeRepository''|http://github.com/TiddlySpace/tiddlyspace|
|''CoreVersion''|2.6.0|
!Usage
Add a control button to revert to a particular revision.

The button must be called from within a revision, as generated by TiddlySpaceRevisionView
!Code
***/
//{{{
(function($) { config.commands.revert = { text: "revert", tooltip: "make this revision the current one", handler: function(ev, src, title) { var revElem = story.getTiddler(title); var tidToRevert = store.getTiddler($(revElem).attr("revName"));

var revision = store.getTiddler(title);
if ((revision) && (tidToRevert)) {
tidToRevert.text = revision.text;
var newFields = merge({}, revision.fields);
for (var fieldName in newFields) {
if (fieldName.substr(0, 7) === "server.") {
delete newFields[fieldName];
}
}
merge(tidToRevert.fields, newFields);
tidToRevert.tags = merge([], revision.tags);
tidToRevert.fields.changecount = 1;
delete tidToRevert.fields.doNotSave;

store.saveTiddler(tidToRevert.title, tidToRevert.title,
tidToRevert.text, null, null, tidToRevert.tags,
tidToRevert.fields, false, tidToRevert.created, tidToRevert.creator);

autoSaveChanges(true);
}
}
};

})(jQuery);
//}}}
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xl="http://www.w3.org/1999/xlink" version="1.1" viewBox="2 724 68 55"
width="30" height="30">
<g stroke="none" stroke-opacity="1" stroke-dasharray="none" fill="none" fill-opacity="1">
<g>
<path d="M 2.25 756 L 11.25 747 L 24.75 760.4994 L 60.750004 724.4994 L 69.75 733.49902
L 24.749977 778.49976 Z" fill="#101010" class="glyph"/>
</g>
</g>
</svg>
[encoded data, 71360 characters]
!!Parent page

We are wondering [[whether a Sigma_2 property might work for proving circuit complexity lower bounds|Could we use a Sigma_2 property?]]. We are going to focus on $$\Pi_2$$ properties instead, pretend we have such a property and see if we can say anything interesting about it.

!Introduction

Let us attempt to plan a proof that if $$f$$ has circuit complexity at most $$m$$, then $$f\notin L$$. That is, for some target function $$g$$, $$f\oplus g$$ has circuit complexity greater than $$m$$. (It is not actually necessary to look at the problem like this: if you prefer, take the aim to be to show merely that $$f\ne g$$.) The one thing that makes this different from the general problem of [[whether there is an NP function of superpolynomial circuit complexity|Do NP functions have polynomial circuit complexity?]] is that we are insisting that the proof should contain an intermediate statement of the form $$\forall A\ \exists B\ P(f,A,B)$$. We have already observed that it appears that we will need to construct $$B$$ out of $$A$$ and the circuit $$C$$ of size $$m$$ that computes $$f$$.

A very simple observation is that there ought to be a genuine dependence of $$B$$ on $$A$$. If we don't have this -- that is, if we can choose $$B$$ independently of $$A$$ -- then we have an intermediate statement of the form $$\forall A\ P(f,A,B_0)$$. This is a $$\Pi_2$$ statement, so if it applies to every function in $$K$$ then it applies to almost all functions.

Let us also think about how we might prove that $$g$$ does //not// have the given property. That tells us that from $$g$$ we can construct an $$A$$ such that no $$B$$ satisfies $$P(g,A,B)$$.

So far there doesn't seem to be anything obviously impossible about all this. But we haven't yet made any attempt to incorporate the pseudorandomness assumption we are making about $$K$$ (and, if we like to formulate it that way, $$L$$). How might that make a difference?

There is an intuition I want to capture. It may well be false, but I'd like to try to state it as precisely as possible so that I can think about whether it is true. It's that it appears to be very hard to give an example of an NP property that is //interestingly// implied by the property "has circuit complexity at most $$m$$'.

A couple of "boring" ways of implying other properties are as follows.
#Take the set of functions of circuit complexity at most $$r$$ for some fixed $$r>m$$.
#Take the union of "has circuit complexity at most $$m$$" with any other NP property.
I think it would be interesting to try to understand what "boring" means in this context. To do that appears to necessitate delving more deeply into the logical system we might consider using in order to prove the result. As such, it deserves a new page. [[ClarifyQuestion|What counts as an "interesting" consequence of low circuit complexity?]]
!!Parent page

We are wondering [[whether a more general Ramsey property would allow us to find an analogue of Martin's theorem|Can we find an analogue of Martin's theorem by thinking about more general Ramsey properties?]].

!Introduction

Suppose we had a suitable Ramsey property. That is, suppose that for every complexity structure $$X$$ we could define a class of sets $$\mathcal{F}(X)$$ (or if we want an asymmetric Ramsey theorem, two classes of sets, but for simplicity I'll go for just one), such that for every $$A\subset X$$ either $$A$$ or $$A^c$$ contains a set in $$\mathcal{F}(X)$$. (In a parallel thread I am working on the idea that sets that are in some sense "half dimensional" might be a suitable class.) Define a //Ramsey lift// to be a lift $$\pi:Y\to X$$ that preserves the Ramsey property, in the following sense: for every $$F\in\mathcal{F}(Y)$$, $$\pi(F)$$ has a subset in $$\mathcal{F}(X)$$. (There is nothing to stop us insisting that $$\mathcal{F}(X)$$ is a monotone class of sets for every $$X$$. If we do that, then the statement becomes that $$F\in\mathcal{F}(Y)$$ implies that $$\pi(F)\in\mathcal{F}(X)$$.)

What we are hoping is that every set $$A$$ can be Ramsey lifted to a subset $$\pi^{-1}(A)$$ of some complexity structure $$Y$$ inside which it is "simple", in the sense that it can be built rather easily out of basic sets. Moreover, we are hoping that this can be done with a significantly smaller $$Y$$ if $$A$$ has small circuit complexity than it can in general.

The main worry is that since all this is inspired by an infinitary argument, any reasonable definition we come up with will not work because the parity function will turn out to be as hard to lift as a general function.

One way to think about that worry is to attempt to find a good lift for the parity function. Another way is to think about whether there is any prospect of showing that functions with low circuit complexity can be efficiently lifted. It is the second approach that is the subject of this page.

!What is a "simple" set?

A //basic// set is a set of the form $$\{x\in X:x_i=\gamma\}$$. Given that for Martin a "simple" set is a set that is both closed and open, it seems natural to try to imitate that. The obvious definition (not completely precise) of an open set is that it is an intersection of a small number of basic sets. And then an open set is a union of basic open sets. So if $$U$$ is an open set and $$x\in U$$, then there exists a small set of coordinates such that every $$y$$ that agrees with $$x$$ in those coordinates belongs to $$U$$. A closed set is a complement of an open set.

!Now let's just go ahead and try to start the proof

Here I am applying the technique """SuspendDefinition""". That is, I don't have precise definitions for all the words and phrases I shall use, but I hope that if I try to write out a proof anyway, the worst that will happen is that I am forced to clarify the vague definitions I have (by adding properties that they must satisfy to make the proof work).

Let $$A_1,A_2,\dots,A_m\subset\{0,1\}^n$$ be a straight-line computation. <<slider chkStraightLineDefinition "Definition of straight-line computation" "Meaning?" "Reminder of definition">> Let $$\pi:X\to\{0,1\}^n$$ be a Ramsey lift <<slider chkRamseyLiftDefinition "Definition of Ramsey lift" "Meaning?" "Reminder of definition">> such that all of $$\pi^{-1}(A_1),\dots,\pi^{-1}(A_{m-1})$$ are simple. I would now like to find a Ramsey lift $$\phi:Y\to\{0,1\}^n$$ such that all of $$\phi^{-1}(A_1),\dots,\phi^{-1}(A_m)$$ are simple.

There is an obvious way to do that, which is to find a Ramsey lift $$\psi:Y\to X$$ such that $$\psi^{-1}(\pi^{-1}(A_m))$$ is simple. Since lifting preserves simplicity (because it preserves basic sets and Boolean operations), we will automatically also have that the other $$\psi^{-1}(\pi^{-1}(A_i))$$ are simple. And since a composition of Ramsey lifts is a Ramsey lift, we can then set $$\phi=\psi\circ\pi$$.

This gives maybe some small grounds for hope, but we still face the major worry that as we proceed with this argument the size of $$Y$$ may blow up rapidly. If it does, then this proof attempt will fail miserably in a similar way to many proof attempts before it.

!!How do we find the lift that makes the last set simple?

To save writing, let us suppose that $$A_1,\dots,A_{m-1}$$ are already simple. (Another way of saying this is that we are renaming $$\pi^{-1}(A_i)$$ as $$A_i$$.) Then there are three cases to consider: the case where $$A_m$$ is a complement of some $$A_i$$, the case where it is an intersection of two earlier $$A_i$$ and the case where it is a union of two earlier $$A_i$$.

Assuming that we are going with open and closed sets as our definition of simplicity, the first case is trivial: the complement of a simple set is //already// simple. Also, if we can prove the result for intersections, then we have it automatically for unions, by de Morgan's laws and the fact that complements of simple sets are simple. So let's look at the following problem. We have two sets $$B$$ and $$C$$ that are open and closed, and $$A=B\cap C$$. We would like to find a Ramsey lift $$\psi:Y\to X$$ such that $$\psi^{-1}(A)$$ is open and closed.

Since the intersection of two closed sets is closed, $$A$$ is closed, and therefore $$\psi^{-1}(A)$$ is automatically closed. So the hard part is to choose $$\psi$$ so as to make $$\psi^{-1}(A)$$ open.

You might say, "Yes, but isn't the intersection of two open sets open?" but this is where "finite topology" differs from genuine topology. It cannot be the case that the intersection of any two open sets is open, since then by induction an arbitrary intersection of open sets would be open and we would have (in any interesting case) that all sets are open. So we have to regard an intersection of two open sets as somehow "less open" than the original sets.

This applies to my rough definition above. I said that an open set was a union of basic open sets, and a basic open set was an intersection of a small number of basic sets. Suppose we call a basic open set $$k$$-//basic// if it is the intersection of at most $$k$$ basic sets, and we call a set $$k$$-//open// if it is a union of $$k$$-basic sets. Then the best we can say about an intersection of two $$k$$-open sets is that it is $$2k$$-open.

If we make $$k$$-open and $$k$$-closed the property we want our sets to have (for some appropriate $$k$$ yet to be chosen), then our task is reduced to finding a Ramsey lift that turns a set that is $$2k$$-open and $$k$$-closed into a set that is $$k$$-open and $$k$$-closed.

For now I'll set this question aside and think more about what I hope the answer will be.

!What kind of result would we need to be true for the blow-up not to be too fast?

Let's be very optimistic and assume that we can lift a $$2k$$-open and $$k$$-closed set to a $$k$$-open and $$k$$-closed set while only doubling the size of the alphabet $$\Gamma$$. Then the size of the alphabet for a set of circuit complexity $$m$$ would be at most $$2^m$$. That looks worryingly large, but maybe there is a small chance that it is OK. In the tree case, the lift that worked for everything was //doubly// exponential in size. (See the section "A trivial upper bound" of [[this page|Can games with low-complexity payoff sets be lifted to not much larger games with payoff sets that are closed and open?]] for details.) Although I did not prove that that trivial upper bound could not be improved, the mere fact that it exists and is rather natural is quite promising -- it shows that doubly exponential bounds can arise. And obviously for $$2^m$$ to become doubly exponential one would need an exponentially large $$m$$.

The double exponential in the games case comes from the fact that there are doubly exponentially many strategies for Player I. So we would almost certainly need there to be doubly exponentially many (or at least, far more than exponentially many) sets in our class $$\mathcal{F}(\{0,1\}^n)$$ for the approach to have a chance of working. Fortunately, this seems to be very much the case.

!Conclusion

More generally, if the most efficient Ramsey lift we can find for an arbitrary set requires us to multiply the size of the alphabet by $$2^{f(n)}$$ and if making an intersection of simple sets simple requires us to multiply the size of the alphabet by $$2^{g(n)}$$, then we will be able to distinguish sets of circuit complexity $$m$$ from arbitrary sets provided that $$m\leq f(n)/g(n)$$. If $$f(n)$$ is exponential and $$g(n)$$ is bounded, that is of course fantastic, but we do not need them to be anything like as good as that to prove something interesting.

One final thought I want to mention here is that we obviously need to do something non-trivial to find the lift that makes a $$2k$$-open and $$k$$-closed set into a $$k$$-open set. This feels not a million miles from Håstad's switching lemma, so something I want to think about is whether that lemma, or some modification of it, could possibly do the job that the """Gale-Stewart""" theorem does in Martin's proof.

So I feel that although my worries are still very much alive, the proof attempt is not yet dead.

<<image SiteIcon>> {{tiddlerEditable{<<tiddler SiteInfo>>}}}
!!Parent page

We are trying to [[find a good definition of "half-dimensional sets"|What is the right definition of a "half-dimensional set"?]].

!Introduction

As suggested in [[this post|Is there a realistic proposal for how an eventual proof might look?]], let us define a $$k$$-basic set to be an intersection of at most $$k$$ basic sets and a $$k$$-open set to be an arbitrary union of $$k$$-basic sets. Suppose now that we have a $$k$$-open set $$U$$. The Ramsey property of half-dimensional sets tells us that either $$U$$ or $$U^c$$ contains such a set. But can we use the openness of $$U$$ to say more? If so, can we prove the stronger statement in a way that is analogous to the proof of the """Gale-Stewart""" theorem?

!An attempt

What does the usual """Gale-Stewart""" theorem tell us, over and above the fact that open games are determined? I want to try to answer this question in a way that makes sense in different contexts.

One way to regard it is as follows. Inside the tree $$T$$ on which the game is played, there is a set of vertices $$S$$, which consists of all vertices $$v$$ with the property that every infinite path through $$v$$ belongs to the payoff set. We can think of $$S$$ as effectively being the payoff set: if Player I has a winning strategy for reaching a vertex in $$S$$, then she wins the game, and otherwise Player II wins.

If Player II has a winning strategy, we can describe it as follows. Given the set $$S$$, let $$W(S)$$ be the set of all vertices from which Player I has a winning strategy for arriving in $$S$$. Then all Player II has to do is avoid moving to a vertex in $$W(S)$$. The proof that this works is an easy induction: the root is not in $$W(S)$$, or Player I would have a winning strategy for the game, and if $$w$$ is any vertex in $$W(S)$$ at even distance from the root, then whatever Player I does, Player II can respond with a move to a vertex in $$W(S)$$, or $$w$$ would not be in $$W(S)$$.

Actually, what I have described is not a strategy but a //quasistrategy// -- that is, like a strategy except that instead of saying what move you will do when it's your turn, you give a set of moves, any one of which you are prepared to do.

In the finite set-up, we are thinking of vertices of game trees as sets of leaves (each vertex corresponding to the set of leaves that are descended from that vertex). So the analogous argument for $$k$$ open sets ought to be something like this.

First, let me give the rough description of what a half-dimensional set is. We inductively define a set $$A$$ to be half-dimensional if for over half the top-level neighbourhoods $$U$$, the intersection $$A\cap U$$ is half-dimensional in $$U$$. At the very bottom level, a half-dimensional set is simply one that contains over half the points of the neighbourhood. (There are technical difficulties with what I am saying, but I don't want to worry about those for now.)

If we have a $$k$$-open set $$A$$, then I would like to try to find not just a half-dimensional set, but one such that after $$k$$ levels in the above inductive definition you get to a neighbourhood that is entirely contained in $$A$$. (This corresponds to reaching a vertex in the game case from which all paths belong to $$A$$.) Let us call that a $$k$$-//strongly// half-dimensional set.

Let me again not try to make that precise. Instead, I'd like to see whether it leads to an analogue of the "canonical quasistrategy for Player II" described above. Let us simply take all the neighbourhoods inside which $$A$$ is not $$k$$-strongly half dimensional. This corresponds to the set of vertices that do not belong to the set $$W(S)$$ of winning positions for Player I. To be clear, when I say that $$A$$ is $$k$$-strongly half dimensional inside a neighbourhood at level $$r$$, I mean that you have to be entirely in $$A$$ at level $$k$$, rather than having to be entirely in $$A$$ at level $$r+k$$. So the $$k$$ is absolute, rather than relative to the level of the neighbourhood.

There appears to be a snag here, or at least a difference that may make a """Gale-Stewart-inspired""" theorem more difficult than the """Gale-Stewart""" theorem itself. It's that if we have two incomparable vertices in a tree, then the set of infinite paths through one is disjoint from the set of paths through the other. That is, the corresponding neighbourhoods are disjoint. Here, however, two basic $$k$$-neighbourhoods intersect in a basic $$2k$$-neighbourhood. So it is not clear that what I'm about to try to do will work.

What //am// I about to try to do? More precisely, what set am I going to take as my "canonical half-dimensional set" in $$A^c$$ if $$A$$ is $$k$$-open and does not contain a $$k$$-strongly half-dimensional set? As in the tree case I can identify a set of promising neighbourhoods. However, a path in an infinite tree is contained in a unique neighbourhood at each level, whereas a point in $$\{0,1\}^n$$ is contained in many neighbourhoods at each level.

!Conclusion

It looks as though we cannot expect an easy modification of the """Gale-Stewart""" theorem to this new context.

This brings me back to an earlier thought: perhaps [[Håstad's switching lemma|http://en.wikipedia.org/wiki/Switching_lemma]] will play a role somehow.
!!Parent page

We are looking at [[whether the obvious game could give us a useful analogue of Martin's theorem|Can we find an analogue of Martin's theorem using the obvious game?]].

!Introduction

We would like to consider one natural approach to this question, which is to try to show that if $$A$$ is a payoff set with low circuit complexity, then $$A$$ is not just determined, but determined with a winning strategy that is in some way "simple".

To get a handle on what a simplicity property for strategies might be like, it seems a good idea to look at some examples.

!Example 1: coordinate hyperplanes

If the payoff set is the set of all $$x$$ such that some particular coordinate $$x_i$$ takes some particular value, which without loss of generality we may take to be 1, then there is a very obvious winning strategy: the player who gets to choose $$x_i$$ chooses it to be 1.

Note that this definition of simplicity is implicitly placing a structure on the tree on which the game is played, so that we can say that choosing a 1 after one sequence $$(x_1,\dots,x_{i-1})$$ is in some sense "the same move" as choosing it after another.

!Example 2: the parity function

The result of this game is not decided until the very last move. However, we can still describe a strategy that is in some sense "forgetful". Suppose for the sake of example that $$n$$ is even and that Player II is trying to end up with an even number of 1s. Then the following strategy works: at each move, do whatever Player I has just done.

This strategy looks back only one move, so is in some sense still "local".

!Example 3: a more general linear function

Suppose we take a subset $$E$$ of $$\{1,2,\dots,n\}$$ and take as our function the parity of the restriction of the sequence to $$E$$. If $$E$$ contains no points in a long interval $$I$$, then there cannot in general be a winning strategy that is "local" in the sense of depending only on the last few moves. To see this, let us consider an extreme case, where $$n$$ is even and $$E$$ is the set $$\{1,n\}$$. Then Player II has an easy winning strategy, but that strategy depends critically on what Player I does on the first move. If Player II uses a strategy that does not depend on that first move, then Player I can easily win.

This example is not too threatening, however, since we can modify the definition of "local" to mean something like "depends on only a very small number of other moves". (The difference is that those other moves don't have to be recent.)

!Example 4: a linear function with no local winning strategy

Suppose $$n$$ is even and we take $$E$$ to be the set $$\{1,3,5,\dots,n-1,n\}$$. Then Player II has the following winning strategy: if $$x_1+x_3+\dots+x_{n-1}=0$$ mod 2 then choose $$x_n$$ to be 0 and otherwise choose it to be 1. (I'm assuming that Player I wants the parity of the restriction to $$E$$ to be 1 and Player II wants it to be 0.) Unfortunately, any way of choosing $$x_n$$ that does not depend on all of $$x_1,x_3,\dots,x_{n-1}$$ does not give a winning strategy, since if it doesn't depend on $$x_i$$ then changing Player I's choice of $$x_i$$ and nothing else changes the eventual outcome of the game.

!How are we doing so far?

Is there a reasonable definition of simplicity that covers all the examples above? One idea is the following. Define a strategy to be $$k$$-//simple// if the player who plays it can still win even if she lets the other player choose all but $$k$$ of her moves. Every linear function is 1-simple, since the player who gets to choose $$x_{\max E}$$ can win even if the other player chooses all other $$x_i$$.

One situation I have not thought about all that hard is who wins the game when the payoff set $$A$$ is an affine subspace of codimension not necessarily equal to 1. It is possible for $$A$$ to be very small and yet for one player to have a winning strategy. For example, the subspace defined by the equations $$x_1=x_2,x_3=x_4,\dots,x_{n-1}=x_n$$ has codimension $$n/2$$ but is trivially a win for Player II. ''//Open task: analyse the game completely in the case that the payoff set is an affine subspace, not necessarily of codimension 1.//''

However, looking at games with subspaces as payoff sets is surely not going to be sufficiently general. Ultimately we would like to show that [[a random function of low circuit complexity|A model of random functions of circuit complexity at most m]] gives rise to a simple strategy. This is going to be very challenging, since random low-complexity functions are highly pseudorandom (or at least they appear to be). Linear functions are nothing like random enough to be representative.

Do we have to jump straight to random functions of low circuit complexity? No we don't. It seems sensible to look first at //quadratic// functions, by which I mean quadratic forms over $$\mathbb{F}_2$$.

!Example 5: a quadratic function that is not $$k$$-simple for any small $$k$$

Suppose that $$n$$ is even and consider the function $$q(x)=x_1x_2+x_2x_3+\dots+x_{n-1}x_n$$. Suppose that Player I plays the following strategy: she keeps playing 1 until the first time Player II plays a 1, and after that she plays 0. The only way that Player II can defeat this strategy is if he plays nothing but 0s. Furthermore, Player II wins against any strategy if he plays nothing but 0s. So Player II has a winning strategy, but he needs control over all his moves. So his best strategy is $$n/2$$-simple, which is of course a trivial upper bound.

!What next?

The fact that a few rather simple-minded ideas do not work is not at all surprising. There is another idea that potentially gives a much more complicated definition of a "simple" strategy, but it raises very serious difficulties of another kind. It is to say that a strategy $$\sigma$$ is simple if it is in some sense simple //as a function defined on 01-sequences//.

What could that mean, however? Example 4 above is particularly troubling, since any winning strategy involves choosing $$x_n$$ to equal the parity of $$x_1+x_3+\dots+x_{n-1}$$. So to call a winning strategy for that game simple we will have to regard the parity function as simple in some way. But that is more or less exactly what we are trying to do already.

I find these observations sufficiently discouraging that I want to pursue other approaches. However, I don't feel I've given a completely clinching argument against this approach.

''//Open task: think further about whether there might be some notion of "simple" strategy for which it can be shown that games with payoff sets of low circuit complexity have simple winning strategies.//''

!!Parent page

We are wondering [[what sort of set could squeeze between a random-looking NP set and a random-looking co-NP set|What sort of set could squeeze between a random-looking NP set and a random-looking co-NP set?]].

!Introduction

Whereas an NP set can be thought of as one defined using a single "second-order" existential quantification, a $$\Sigma_2$$ set can have an existential quantification followed by a universal one. Rudich's extension of the natural proofs argument suggests that if we are going to prove that some function in NP does not have polynomial circuit complexity, then somewhere along the line we will have to consider a property that is not in NP or in """co-NP""": that is, in some sense it needs at least two (different) quantifiers. What I want to think about here is whether two quantifiers are enough.

I would describe this as applying the move """SwitchToNegation""".

!Why might two quantifiers //not// be enough?

Again, let $$K$$ be the set of functions of circuit complexity at most $$m$$ for some suitable $$m$$ and let $$g$$ be a target function in NP. For convenience I'll write $$L$$ for $$g\oplus K$$. We are trying to find a set $$S$$ that separates $$K$$ and $$L$$ in the sense that $$K\subset S$$ and $$L\subset S^c$$. We also want $$S$$ to be "non-trivial" in some sense that is hard to pin down.

The best I can do so far in pinning it down is this. Rudich's result tells us (if certain plausible conjectures are true) that if $$S$$ is an NP set, then it will have to be very small, and if it is a """co-NP""" set, then it will have to be very large. Thus, if we only ever deal with NP and """co-NP""" properties, there will have at some stage to be a "jump" from a property $$S$$ that holds for almost no functions (but all functions in $$K$$) to a property $$T$$ that holds for almost all functions (but no functions in $$L$$). That makes it sound as though getting from $$S$$ to $$T$$ might be more or less as hard as the original problem, though I do not have a rigorous argument that captures this intuition.

What I am trying to do here is decide whether this apparent "jump" phenomenon persists even if we allow separating sets at the next level up in complexity: that is, $$\Sigma_2$$ and $$\Pi_2$$ sets.

A simple point to get out of the way is that a $$\Sigma_2$$ set that contains $$K$$ and is disjoint from $$L$$ does not have to be very small and it does not have to be very large. That is because both NP sets and """co-NP""" sets are $$\Sigma_2$$ sets. But that still leaves two (not independent) questions.

#If a $$\Sigma_2$$ separating set $$S$$ is not in """co-NP""", so in some sense the existential quantifier is necessary, does that then imply that $$S$$ is small?
#Can there be a $$\Sigma_2$$ separating set of "intermediate size" -- that is, neither very small nor very large?

!!Remark

In a sense, I have both weakened and strengthened the question here. I have passed from thinking about whether a $$\Sigma_2$$ property could be used in a proof to thinking about whether using a $$\Sigma_2$$ property would still entail some kind of "jump". This is a more specific thing to ask, so in that sense stronger, but since I don't have a convincing argument that one cannot actually make a "jump" in this sense, it is also weaker.

!What could conceivably force a "genuine" $$\Sigma_2$$ separating set to be small?

There is a short answer to this, but it is just an obvious and very small reduction of the problem: if $$L$$ is pseudorandom for "genuine" $$\Pi_2$$ sets, then $$L$$ cannot be contained in a "genuine" $$\Pi_2$$ set unless that set contains almost all functions. Equivalently, $$L$$ cannot be disjoint from a "genuine" $$\Sigma_2$$ set unless that set is tiny.

So let us phrase the question in that way instead: is it conceivably the case that the sets $$K$$ and $$L$$ are pseudorandom for "genuine" $$\Pi_2$$ sets? (Just to be clear: I mean by this that if $$S$$ is any "genuine" $$\Pi_2$$ set, then the relative density of $$S$$ inside $$K$$ or $$L$$ is roughly the same as the density of $$S$$ in the set of all Boolean functions.)

What this would be saying is that if the statement "$$f$$ has circuit complexity at most $$m$$" implies a statement $$S(f)$$ of the form $$\forall A\ \exists B\ P(f,A,B)$$, where $$A$$ and $$B$$ are certain "second-order" objects, then either that statement holds for almost all functions or there is a kind of "collapse" and we can reformulate the statement in a way that requires just one existential quantifier: that is, as a statement of the form $$\exists C\ Q(f,C)$$.

At this stage, I'm not looking for anything even remotely like a proof. I'm not even looking for a convincing heuristic argument that the statement is true. I'm just trying to convince myself that the idea is not ridiculous -- that it //might// be true. Here are two ways that I might go about it.
*Try to find an apparent counterexample (that is, an apparently genuine $$\Pi_2$$ set that contains $$K$$ and does not contain almost all functions) and be encouraged if I fail. (''//Open task: do this//''.)
*Try to identify some vague reason that one might expect the statement to be true. I'll go for the second here.

If we're trying to deduce that $$\forall A\ \exists B\ P(f,A,B)$$ from the fact that $$f\in K$$, then for each $$A$$ we need the NP property $$\exists B\ P(f,A,B)$$ to hold. So we are asking for low circuit complexity to imply a large variety of interrelated NP properties. In order for the intersection of all these sets not to be small, we need all these properties $$\exists B\ P(f,A,B)$$ to be large, which suggests that they will apply to several functions in $$L$$.

So far I don't see any hint of a contradiction. Why couldn't there be a large number of large NP properties that intersect in a set that is only moderately large?

To make this possibility more concrete, let's imagine what the statement might be like that we would deduce from low circuit complexity. We would be given a function $$f$$, a polynomial-sized circuit $$C$$ that computes $$f$$ and some object $$A$$. From that we would like to deduce that there exists $$B$$ such that $$P(f,A,B)$$. So we would be trying to build an object $$B$$ out of $$C$$ and $$A$$ (and possibly $$f$$ as well) such that something interesting is true about how $$f$$ relates to $$B$$.

On the face of it, this seems like a reasonable possibility. But there is still a slightly odd "jump" phenomenon if we are trying to find a property that holds for many more functions than just the ones with low circuit complexity: for each $$A$$ we have to use the property that $$f$$ is computed by the small circuit $$C$$ to prove a conclusion (that an appropriate $$B$$ exists) that in fact holds for a much wider class of functions.

Is that "slightly odd"? I'm not sure. A difficulty with thinking about this kind of thing is that it is always possible to devise uninteresting examples, such as ones that are derived from a trivial weakening of the original hypothesis -- for example, allowing the circuit complexity to be larger. But I think we can deal with that kind of difficulty by observing that if we begin by deducing a trivial weakening, then all that does is reduce the task to showing that the trivial weakening is disjoint from $$L$$, and that is a problem of more or less exactly the same type that we started with. So what I want to do is focus on the first point where we make a //non//-trivial deduction.

The unspoken motivation underlying this page was this: I hoped that maybe I would think of a plausible (though highly nonrigorous) argument that even $$\Sigma_2$$ separating properties are unlikely to be helpful for proving circuit complexity lower bounds, and that the argument would generalize to the entire polynomial hierarchy (that is, to all properties with a bounded number of alternating "second-order" quantifiers). However, I haven't come up with a convincing such argument, so instead I want to focus on what a proof that used a $$\Sigma_2$$ property might look like. A small technical detail is that I found it convenient to switch my attention to $$\Pi_2$$ properties.

What move am I applying? I started by wanting to show that there does not exist a set $$S$$ with certain properties. Finding myself unable to do that, I am going to try a useful technique: attempt to find such a set. Except that it's slightly more complicated: I have no idea how to find such a set, so instead I "pretend I already have the set" and try to continue with the proof. The hope is that as I proceed, I find that I need the set to have certain properties. This narrows down what I am looking for.

This general technique is one that Mohan Ganesalingam and I call //suspension//. A more standard name for it in automatic theorem proving literature is using //metavariables//.

So to get to the next page requires a composition of """SwitchToNegation""" (which gets us back to trying to find a suitable $$\Pi_2$$ set) and [[SuspendObject|What might a proof using a Pi_2 property look like?]].
Once you have some content then you may choose to determine a tiddler, or set of tiddlers to display each time you load ~TiddlySpace. This is determined by the [[DefaultTiddlers]].
<!DOCTYPE html>

<meta http-equiv="Content-Type" content="text/html;charset=utf-8">
<title>This Space</title>

home

Site Icon

<input type="hidden" name="title" value="SiteIcon" />
<input type="hidden" name="tags" value="excludeLists">
<input type="hidden" name="csrf_token" class="csrf" />
<input type="file" name="file" accept="image/*" />
</form>

Drop file here

Vital Statistics

<button class="spacereset">Reset Space</button>

<button class="close-btn" title="cancel reset">×</button>

Are you sure you want to reset the space? You can't go back! This will remove all the content from the space!

<form class="cf">
Enter the space name to confirm.
<input type="text" name="reset-confirm" class="reset-confirm-input inputBox" />
<button type="submit">Reset Now</button>
</form>

Resetting...

Reset Done!

Error removing includes. Please remove manually.

What is a Member?

Add a new member to your space by entering their name below. Enter a space name instead and prefix with @ to add everyone who is already a member of that space.

<form class="ts-members">
<input type="submit" value="Add Member" class="btn" />
</form>

Existing Members <button class='toggleNext'></button>

Your space currently has the following members:

Include Space
What is Inclusion?

<form class="ts-includes">
<input class="inputBox" type="text" name="spacename">
<input type="submit" value="Include Space" class="btn" />
</form>

Included Spaces <button class='toggleNext'></button>

This space includes the following spaces:

!!Parent page

We are trying to [[find an analogue of Martin's theorem using the obvious game|Can we find an analogue of Martin's theorem using the obvious game?]]

!Introduction

In this page we shall consider the following approach. Martin proves his theorem by proving that every Borel game can be lifted to a closed and open game. <<slider chkLiftDefinitionReminder "What is a lift?" "What is a lift?" "Reminder of lift definition">> Since open games are determined and a game is determined if it can be lifted to a determined game, this proves the result. The hope is that in the finite case we can prove that every game with a low-complexity payoff set can be lifted to a game that is in some sense "closed and open" and with a tree that is not //too// large, whereas a general game can only be lifted if the tree is very large indeed.

!A trivial upper bound

The following observation places a limit on what we could hope to prove. I shall show that there is a lifting of the game played on $$\{0,1\}^n$$ such that the inverse image of //every// payoff set is closed and open. In other words, it is a simultaneous lifting of all games to closed and open games.

The lifting is defined as follows. I'll describe it informally first and indicate how to make it formal later. Player I starts by declaring a strategy $$\sigma$$. Player II responds with a sequence $$x$$ that is consistent with the strategy $$\sigma$$. After that, the two players play the bits $$x_3,x_4,x_5,\dots$$ of the sequence $$x$$. Clearly, whatever the payoff set is for this game, the game is determined after the first two moves, since the sequence is determined after the first two moves.

The tree that this game is played on therefore consists of initial segments of sequences of the form $$(\sigma,x,x_3,x_4,\dots,x_n)$$, where $$x$$ is a sequence that could result if Player I uses strategy $$\sigma$$ in $$\{0,1\}^n$$ and $$x_3,\dots,x_n$$ are the bits of $$x$$ from the third bit onwards. When $$k\geq 2$$ the map $$\pi$$ from this tree to the tree on $$\{0,1\}^n$$ takes the sequence $$(\sigma,x,x_3,\dots,x_k)$$ to the sequence $$(x_1,\dots,x_k)$$, where $$x=(x_1,\dots,x_n)$$, and when $$k=1$$ it takes the sequence $$(\sigma)$$ to the sequence $$(x_1)$$, where $$x_1$$ is the first move that $$\sigma$$ tells Player I to make. It is easy to check that $$\pi$$ satisfies the first two properties from the lift definition.

We still need to define a map $$\psi$$ that takes strategies to strategies. This we do as follows. Let $$\sigma'$$ be a strategy for Player I in the auxiliary game. The only place where Player I has any choice about what to do is in picking a strategy $$\sigma$$ for the original game: thereafter, she is forced to play the bits of the sequence $$x$$ that is chosen by Player II. We define $$\psi(\sigma')$$ to be this strategy $$\sigma$$. (In other words, we write down the most obvious thing we can.)

This trivially satisfies the property we need it to satisfy: given any run $$x$$ of the original game where Player I uses the strategy $$\psi(\sigma')=\sigma$$, there is a run of the auxiliary game that maps to $$x$$, namely the run where Player II chooses the sequence $$x$$ for his first move.

The situation for Player II strategies is not quite as trivial. Player II's only option in the auxiliary game is to choose a sequence $$x$$ that is consistent with the strategy $$\sigma$$ (for the original game) that Player I chooses. So let $$\tau'$$ be a strategy for Player II in the auxiliary game, and let $$X$$ be the set of all sequences $$x=\tau'(\sigma)$$ that can arise. This set $$X$$ has the property that for every $$\sigma$$ there is a sequence in $$X$$ that is consistent with $$\sigma$$. Therefore, by definition of "winning strategy", Player I does not have a winning strategy for the game with payoff set $$X^c$$. Since finite games are determined, Player II has a winning strategy for $$X$$. Let $$\psi(\tau')$$ be such a winning strategy.

Then if $$x$$ is any run of the original game with Player II playing the strategy $$\psi(\tau')$$, we have that $$x\in X$$, which is precisely the statement that $$x$$ is a sequence that could arise if Player II plays the strategy $$\tau'$$ in the auxiliary game.

This proves that the maps $$\pi$$ and $$\psi$$ define a lift. It remains to observe that since the entire run of the auxiliary game is decided after the first two moves, every set of sequences is open and closed (given any reasonable notion of "open and closed" in the finite set-up). In particular, the inverse images of all subsets $$A\subset\{0,1\}^n$$ are all open and closed, as claimed.

!!What bound does that give?

I won't calculate it precisely, but the root of the tree we defined for the auxiliary game has one successor for every strategy. Since a strategy includes a Boolean function defined either on all sequences of length $$n-1$$ or on all sequences of length $$n-2$$, there are doubly exponentially many strategies.

Each successor of the root has around $$2^{n/2}$$ successors in its turn, but since this is only singly exponential, it does not make too much difference to the size.

So the obvious question we are left with is this: do games with payoff sets with low circuit complexity have lifts to games with "closed and open" payoff sets and much smaller than doubly exponential size?

Another question that interests me is whether the doubly exponential bound just given is necessary. ''//Open task: determine whether for a random payoff set one typically needs a lift to a tree of doubly exponential size.//''

!The simplest sets of all

It seems sensible to start by thinking about the case where the payoff set is a coordinate hyperplane. I will condense quite a lot of thought, most of which had to be abandoned and is no longer all that interesting (as far as I can tell), into a couple of small observations.

!!First observation

Let $$A$$ be any payoff set that depends on just the first $$k$$ coordinates. Then we can modify the "trivial lift" defined above, as follows. In the auxiliary game, Player I starts by declaring a strategy $$\rho$$ for the first $$k$$ moves. Player II then declares a sequence $$u$$ of length $$k$$ that is consistent with $$\rho$$. The players must then play the sequence $$u$$ for the first $$k$$ bits, and thereafter they are free to play as they like. The map $$\pi$$ is defined in the obvious way. As for $$\psi$$, it is defined as follows. Given a strategy $$\sigma'$$ for Player I in the auxiliary game, there will be a strategy $$\sigma$$ (for the original game) that says what to do for the first $$k$$ moves of the original game. We define $$\psi(\sigma')$$ to be the strategy that plays according to $$\sigma$$ for the first $$k$$ moves and according to $$\sigma'$$ for the remaining moves. <<slider chkDefinePsiPrecisely "What does according to sigma mean?" "Meaning?" "Make more precise">> As for a Player II strategy $$\tau'$$, let $$X$$ be the set of all possible first moves that Player II could make if he plays $$\tau'$$. Then $$X$$ is a set of sequences of length $$k$$ that includes at least one sequence consistent with every Player I strategy $$\rho$$ for the first $$k$$ moves. So Player II has a winning strategy $$\gamma$$ for $$X$$. We define $$\psi(\tau')$$ to be the strategy that plays according to $$\gamma$$ for the first $$k$$ moves and according to $$\tau'$$ thereafter.

This time the meaning of "according to $$\tau'$$" is slightly less clear so I'll spell it out. After the first $$k$$ moves we have a sequence $$(x_1,\dots,x_k)$$ that comes from at least one sequence of the form $$(\rho,u,x_2,\dots,x_k)$$ that could arise in the auxiliary game with Player II playing the strategy $$\tau'$$. Player II picks such a sequence (that is, chooses $$\rho$$, since $$u$$ is forced to be the sequence $$(x_1,\dots,x_k)$$) and from that point onwards does to $$x_1,\dots,x_r$$ whatever $$\tau'$$ does to the sequence $$(\rho,u,x_3,\dots,x_r)$$.

Note that if $$A$$ depends only on the first $$k$$ coordinates, then the outcome of the auxiliary game with payoff set $$\pi^{-1}(A)$$ is decided after the first two moves. So we have a lift to a closed and open set that gives us a tree of size that is doubly exponential in $$k$$ (and singly exponential in $$n$$), If $$k$$ is much smaller than $$n$$, then this is much smaller than doubly exponential in $$n$$.

!!A worrying feature of this first observation

This shows in particular that for the coordinate functional $$x_k$$, the size of the lift need be "only" doubly exponential in $$k$$. But this massively favours small $$k$$. It is rather odd that coordinate functionals corresponding to large $$k$$ should apparently be much harder to lift than coordinate functionals corresponding to small $$k$$.

But maybe we can find a clever way of lifting the game that corresponds to the set $$x_n=1$$.

!!Second observation

Actually we can't find a clever way, or at least not unless we can find a clever way of lifting the game //whatever// the payoff set might be. This can be shown by means of a simple observation that places a significant restriction on what any proof could look like.

Suppose we could find a lift for the set $$E_n=\{x\in\{0,1\}^n:x_n=1\}$$. Let us think about this in terms of the tree structure on $$\{0,1\}^n$$. The game takes place on a binary tree of depth $$n$$, and the set $$E_n$$ contains exactly one leaf out of each final pair of leaves.

But whether or not there exists a lift to some other game is clearly invariant under automorphisms of this binary tree, since we can just compose the map $$\pi$$ with the automorphism. So if there is a particularly efficient lift for the set $$E_n$$, then there is also a particularly efficient lift for //any// set that contains exactly one leaf out of each final pair. For example, there is a particularly efficient lift for the parity function: up to tree automorphism the parity function and the function $$x_n$$ are the same.

It is a straightforward exercise to show that every Boolean function can be built using simple Boolean operations out of four functions that have the property that for each final pair they take the value 0 for one leaf and 1 for the other. So if we can show that there is an efficient lift for the $$E_n$$ game and that efficient liftability is closed under intersection and union of two payoff sets (with perhaps a slight decrease in efficiency), then we have shown that //all// Boolean functions can be efficiently lifted. So the property of efficient liftability is useless for proving lower bounds for circuit complexity.

!!The moral of the second observation

The conclusion I draw is that if we are going to do anything with games, and if we define a property that is invariant under automorphisms of the underlying tree, then we will have to check carefully what sets can be generated easily from not just the sets we consider to have low complexity but also all images of those sets under automorphisms of the tree.

Note that not all properties that we might want to consider are invariant under automorphisms of the underlying tree. For example, when we were looking at [[whether low-complexity sets gave rise to simple strategies|Are games with low-complexity payoff sets "simply" determined?]], we considered definitions that involved concepts such as "depends only on the previous coordinate". This concept involves not just the tree structure but how the vertices are labelled, so it is not automorphism invariant.

!!A further thought

Another way of looking at the difficulty that has arisen is this: when we built a tree out of $$\{0,1\}^n$$ (that is, a tree whose leaves are the points in $$\{0,1\}^n$$), we didn't really think about what the topology on the set of leaves of that tree should be. (There is an obvious one-to-one correspondence between the leaves and paths through the tree of length $$n$$, so this is the finite analogue of the set $$[T]$$ in the infinite case.) And a moment's thought reveals a serious problem here: the obvious "basic open sets" of leaves of $$T$$ are sets of the form "The set of all leaves that are descendants of $$v$$", where $$v$$ is a vertex near to the root. This makes the coordinate hyperplanes $$\{x\in\{0,1\}:x_k=1\}$$ become rapidly less open as $$k$$ increases.

So another moral is that the obvious game topologizes $$\{0,1\}^n$$ in an inappropriate way.
User-agent: *
Disallow: /bags
Disallow: /recipes
/***
|''Name''|ErrorHandlerPlugin|
|''Version''|0.4.3|
|''Author''|Jon Robson|
|''Description''|Localised tiddler save errors including edit conflict resolution.|
|''CoreVersion''|2.6.1|
|''Requires''|TiddlySpaceConfig|
***/
//{{{
(function($) { var tiddlyspace = config.extensions.tiddlyspace; var currentSpace = tiddlyspace.currentSpace.name; tiddlyspace.getLocalTitle = function(title, workspace, suffix) { var endsWith = config.extensions.BinaryTiddlersPlugin.endsWith; if(!suffix) { var isPublic = endsWith(workspace, "_public"); suffix = tiddlyspace.resolveSpaceName(workspace); if(currentSpace == suffix) { suffix = isPublic ? "public" : "private"; } else { suffix = "@%0".format(suffix); } } return "%0 *(%1)*".format(title, suffix); }; var sssp = config.extensions.ServerSideSavingPlugin; var msgs = config.messages.editConflict = { loading: "Loading..", resolve: "[[Edit Conflict]]@glossary: this tiddler may have been changed by someone else.", reviewDiff: "review (recommended)", reviewDiffTooltip: "review changes made to this tiddler", reviewDiffError: "error retrieving revision.", save: "overwrite", saveTooltip: "make this revision the top revision of this tiddler", discard: "cancel", discardTooltip: "undo changes to this tiddler and get most recent version", diffTitle: "%0", diffFieldTitle: "%0 - fields", diffTextTitle: "%0 - text", updating: "updating your version...", diffHeader: ["Review the changes that have been made whilst you were editing this tiddler. ", "Fold relevant changes back into your version.\n", "{{removed{Red}}} highlight shows content removed. ", "{{added{Green}}} highlight shows content added.\n"].join(""), diffTextHeader: "View changes in text", diffFieldsHeader: "View changes in fields" }; var plugin = config.extensions.errorHandler = { diffTags: ["excludeLists", "excludeMissing", "excludeSearch"], displayMessage: function(message, tiddler, context) { var desc = context && context.httpStatus ? context.statusText : sssp.locale.connectionError; var reportArea = plugin.reportError(tiddler.title); var msg =$("
").appendTo(reportArea);
if(message == "saveConflict") {
wikify(msgs.resolve, msg[0]);
var choiceArea = $("
").appendTo(reportArea)[0]; plugin.editConflictHandler(choiceArea, tiddler); } else { msg.text(sssp.locale[message].format(tiddler.title, desc)); } }, editConflictHandler: function(container, tiddler) { var title = tiddler.title; var myrev = tiddler.fields["server.page.revision"]; // note user now needs to edit, fix problem and save. // TODO: make sure this gets reset in save callback store.getTiddler(title).fields["server.page.revision"] = "false"; var diffBtn = createTiddlyButton(container, msgs.reviewDiff, msgs.reviewDiffTooltip, function(ev) { var title =$(ev.target).data("title");
plugin.displayDiff(ev.target, store.getTiddler(title), myrev);
});