Основы лужеиндукционного программирования.

Apr 11, 2016 18:49


Итак вы решили посвятить свою жизнь программированию лужеиндукционных вычислений и наверное, как всегда и бывает в таких случаях, задаетесь вопросом, "Что же это такое?". Но главный вопрос не в этом, "В чем же вопрос?" вот в чем вопрос. А ответ на него, как водится, "Ответ:6".

Попробуем в двух словах описать, как это работает.
Это работает.
Надоже, получилось! Теперь поподробнее:


Основным Дженериковым объектом в лужном программировании является Тумба. Весь процесс разворачивается из Тумбы, но Тумба не может существовать наряду с другими объектами и объявляется только в конце выполнения программы. При этом Тумба существует вне времени, поэтому объявленную в конце кода Тумбу можно использовать в его начале, но не внутри кода.
(Более подробно свойства Тумбы рассмотрены здесь: http://asagalisator.narod.ru/tumba2.html)

Вначале кода из Тумбы объявляется ВСЁ, главное пространство объектов, и в конце оно должно быть схлопнуто в Тумбу. В случае вызова Тумбы внутри кода, ВСЁ схлопывается автоматически и должно быть создано заново.
Начнем наш код вызвав ВСЁ:

Tumba.Create(Everything);
Everything.Collapse(Tumba);

Между этими событиями помещаем код.
Вызов пространства ВСЁ избавляет нас от необходимости возиться с группированием пространства, времени и другими аспектами бытия. Впрочем для более точного дизайна вселенной можно объявлять объекты и вне пространства ВСЁ, например:

Tumba.Create((Time, Space), Tumba.Create(Gabja, digit) in (Time, Space));

(Time, Space){
Gabja.Create(Gabjasinthetase.Create(Gabja2, Gabja3, Gabja4));
(Gabja, Gabja2).Fuse(DoubleGabja.Divide(Dog, Puddle));
(Dog, Puddle).Collide(Bomji);
(Bomji, Puddle).Collide(F-Puddle);
digit.Create(x).Flagged in F-Puddle;
(Gabja3, Gabja4).MoveTo(F-Puddle);
F-Puddle{
     x = 2+2;
(Gabja3, x, Gabja4).Fuse(DoubleInvertedGabja);
}.Evaporise;
}.Collapse(Tumba);

В таком виде Тумба должна напрямую порождать все объекты за пределами экзистенции, причем породив время и пространство, она должна породить саму себя, чтобы внутри этого порождения породить внутрь пространства-времени чтото ещё, так как после порождения первой группы объектов Тумба прекращает своё существование.

Пространство ВСЁ автоматически группирует всё сущее внутри себя, что несколько упрощает построение.
Рассмотрим подробнее, что делает приведенный выше код:

В первой строке мы создаем Объединенные в группу объекты Пространство и Время, а также создаем новую Тумбу, которая создает внутрь пространства и времени объекты Габжа и Число.

Во всем последующем блоке мы схлопывем пространство-время обратно в Тумбу, при этом выполняя в нем следующие действия:

Посредством объекта Габжа мы создаем Габжесинтетазу, посредством которой тут же создаем Габжу2, 3 и 4. Здесь нужно рассмотреть Габжу подробнее.
В отличие от Тумбы, объекты внутри бытия не перестают существовать, порождая что либо, хотя и не все объекты могут чтото порождать. Габжа в физическом представлении выглядит как миска с жижей и способна порождать Габжесинтетазу.
Синтетазы являются объектами для многократного порождения того, синтетазой чего они являются. При отсутствии пространства ВСЁ это единственный способ порождать чтото внутри других пространств, плюс они могут быть полезны в бесконечном порождении. О том, как получить синтетазы других объектов, мы поговорим позже.

Так вот у Габжи есть несколько важных свойств: Две Габжи можно объединить тремя способами, получая ДаблГабжу, ДаблИнвертедГабжу или ДаблФлэтГабжу. Первая это две миски, соединенные донышками, сразу же распадается, так как одна из мисок находится вверх ногами. Жижа из ДаблГабжи при этом образует Лужу, а оставшееся преобразуется в Собаку (Об этом позже).
ДаблИнвертедГабжа соединена каемками и потому полностью закрыта. Это изолированный объект, который способен пережить смерть пространства, в котором находится (кроме пространства ВСЁ).
ДаблФлэтГабжа образована плоскими двумерными Габжами, а потому находится в суперпозиции двух предидущих и способна к адсорбции Лэнгмюра, что является предметом для более сложных операций.
В данном случае из двух габж методом Fuse мы породили Даблгабжу и сразу разделили её методом Divide на два новых объекта.



Итак через Даблгабжу мы породили Лужу и Собаку.
В Лужном программировании все вычисления осуществляются в Лужах. Это связано с основным правилом Лужеиндукции, которое гласит, что все Числа равны всем числам. Поэтому чтобы провести какоето квазидетерминированное вычисление, требуется задать для него Лужу с более ограниченной математикой, ибо Лужи они такие.

Собаки являются дополнительным элементом и при удаленности от луж рассматриваются отдельно. При объединении с лужами Собаки могут порождать объекты живой природы. Также Собаки могут проявлять транстемпоральность, в то время как Лужи во времени линейны.

В данном примере приводя во взаимодействие Лужу и Собаку методом Collide мы создаем объект "Бомжи" (Очень популярный объект в АСАГАЛе).

При взаимодейтсвии с бомжами, Лужа трансформируется в ф-Лужу, или так называемую ффффф-Бомжефекалолужу, одну из базовых луж, известных в Лужеиндукции.
Из Объекта "Число" мы создаем переменную Х и помещаем в ф-Лужу. В ней мы производим вычисление 2+2.

Как известно из курса Лужной Географии, в ф-Луже 2+2=4,5,6 и иногда даже7( когда нет в моче ни кислот, ни щелочей). По идее таким образом мы должны получить значение х, лужеиндуцирующееся в пределах от 4 до 7.
(Вспомогательные материалы по Лужной Географии: http://asagalisator.narod.ru/cxa1/259163_1.html)

Однако есть один нюанс:
При создании переменной икс, мы вызвали свойство Flagged и объявили на ней флажок. Флажок содержит детерминированное описание объекта и не дает ему лужеиндуцировать. При обретении значения, переменная получает флажок X.Flag = ya_chislo; таким образом икс будет иметь конкретное значение от 4 до 7.
В довершение мы помещаем икс в ДаблИнвертедГабжу и испаряем Лужу методом Evaporise. ДИГ при этом сохраняет переменную от испарения вместе с лужей.

Рассмотрим что-нибудь посложнее. Вот весьма интересный пример, раскрывающий, как достоинства пространства ВСЁ, так и ряд других полезных инструментов. Данный код довольно сложен, поэтому я буду писать в нем комментарии:

Tumba.Create(Everything);       //Создаем ВСЁ

Everything{
Dog.induct(EndlessCat).Flagged;           //Лужеиндуцируем Собаку в Бесконечную Кошку с флажком
Everything(Gabja).Create(Gabjasinthetase.Create(Gabja)) in EndlessCat;  
//Заполняем БК Габжесинтетазой и создаем в ней бесконечное количество Габж

EndlessCat(Gabja, Gabja).Fuse(DoubleGabja.Divide(Dog, Puddle));   //Делаем Собаку и Лужу
Dog.Time.Backwards;                                             //Посылаем Собаку назад во времени

EndlessCat(Puddle).Regurgitate(Puddle1);                       //Отрыгиваем из БК Лужу1, где х=х
Puddle1.Flag = ya_luja_gde_x=x;

Puddle1{
4):(1,2,9(:);                                                 //делаем 4 равным 1,2,9
Everything(X) = 4 - 2;                                           //считаем икс
Everything(ASAGAL).Create(Bomji);                             //Создаем Бомжей из АСАГАЛа  
(Bomji, Puddle1).Fuse(F-Puddle1);                             //Делаем ф-Лужу из Лужи1
Everything(Y) = Everything(X) + 2;                                                     //Считаем игрек

Everything(Gabja).Scrath(HOLE1);                       //Создаем дырку
HOLE1{  Tumba.Create(ASAGAL, digit(x,y,z)); }         //В дырке вызываем Тумбу и создаем АСАГАЛ и числа
}

EndlessCat(Puddle).Regurgitate(Puddle2);                 //Делаем Лужу2 где х=-х
Puddle2.Flag = ya_luja_gde_x=-x;

Puddle2{
Everything(Z) = Everything(Y);                                       //Достаем Y в Z и суем в ДИГ
EndlessCat(Gabja, Gabja).Regurgitate(Gabja1, Gabja2);
(Gabja1, z, Gabja2).Fuse(DoubleInvertedGabja);
}.Evaporise;

}.Collapse(Tumba);                                       //Всё схлопывается в Тумбу

Итак, что же тут происходит. Сначала из Тумбы мы создаем пространство ВСЁ и работаем в нем вплоть до схлопывания.

Пространство ВСЁ вмещает в себя всё сущее, поэтому через префикс Everything можно вызывать любые объекты, в каком бы пространстве они не существовали, даже если они находятся в другой вселенной, это делает ВСЁ очень удобным.

Внутри пространства ВСЁ мы первым делом Лужеиндуцируем Собаку методом induct, чтобы получить бесконечную кошку.

Оператор лужеиндуцирования позволяет нам превратить объект во что угодно, потому, что по лужеиндукции, все объекты равны всем объектам.
Причем, если вы заметили, Собаку мы ещё не создавали, она вернулась назад во времени из более поздних участков кода, в этом прелесть собак, ибо собаки не Лужи.

Бесконечная кошка является уникальным объектом со свойством бесконечности.
Поэтому мы используем её для бесконечного порождения. заполняя БК габжесинтетазой и производя из неё Габжу, мы получаем бесконечное количество Габжи, что избавляет нас от необходимости создавать Габжу в дальнейшем, теперь её можно просто доставать из БК.

Там же мы создаем Собак и Лужу, после чего посылаем собаку назад во времени через свойство Time.Backwards.
С помощью метода Regurgitate мы отрыгиваем из БК Лужу1 и редактируем её флажок, задавая для этой лужи правило, что любое число в ней не лужеиндуцируется и по умолчанию всегда равно самому себе.

В низкоуровневом лужекодинге, флажок должен содержать в себе особый код, содержащий бесконечное количество информации, исчерпывающе описывающей объект в ограниченном наборе символов, но данный синтаксис допускает и краткие описания, начинающиеся со слова "ya". Таким образом, флажок будет просто содержать надпись "Я Лужа, где х=х"
(О механизме извлечения полного кода флажка можно прочитать тут http://asagalisator.narod.ru/cxa1/432788_1.html)

В Луже1 начинается самое интересное:
Для начала мы задаем лужеиндукционное исключение, делая число 4 равным 1, 2 и 9.
Такие исключения задаются операторами ):( - "человек между подушками" и (:) - "человек в подушке".
Человек между подушками это принцип лужеиндукционного равенства, множества справа и слева от него взаимотождественны, а человек в подушке закрывает исключение в отдельно детерминированное правило.

Дажее мы достаем из ВСЕГО переменную Х и счтиаем в ней 4-2. Результат вычисления будет лужеиндукционным, так как 4 равно толи 1, толи 2, толи 9, толи даже 4, а 2 может быть равно 4. Так что результат флуктуирует в диаапазоне значений (1,2,4,9) - (2,4).

Далее всё становится ещё интереснее, мы вынимаем из ВСЕГО объект АСАГАЛ (Великая Помойка) и создаем из него Бомжей, при помощи которых превращаем Лужу1 в ф-Лужу1.
2+2 теперь равно 4,5,6 и иногда даже7. При этом мы производим вычисление Y = X + 2.
Подумайте сами, чему будет равен Y.

Про АСАГАЛ стоит упомянуть отдельно, в аналоговом мире это контейнер с мусором, он может производить Бомжей, помойный сок, собственно Мусор, а также согласно теореме Волкова "АСАГАЛ АСАГАЛу АСАГАЛ". Однако этот объект заслуживает рассмотрения в более специализированных курсах и здесь мы глубоко вдаваться не будем, дабф не наделать слишком много букв.
(Более подробно про АСАГАЛ и Флажковый Лужеиндукционный Тумбаизм можно прочитать здесь: http://asagalisator.narod.ru/asa1.html)

Возвращаясь к коду, стоит заметить, что здесь мы использовали переменные X,Y,Z, а также АСАГАЛ, которых не создавали в пределах ВСЕГО. Как же нам поступить в этой ситуации? Помимо лужеиндуцирования, которое не всегда оптимально в таких случаях, есть ещё один прием, позволяющий нам создать все недостающие объкты и сразу сделать их доступными на всей временной оси программы.

Для Этого существует операци Тру-Шинтегрирования. Мы берем одну из Габж, коих у нас бесконечно много и трем её методом Scratch. Операция Тру-Шинтегрирования автоматически подвергает объект трению три раза, от чего из него образуется Дырка.

Дырка содержит в себе НИЧТО, тоесть внутри неё нет пространства ВСЁ, там вообще ничего нет, а значит внутри дырки мы можем вызвать Тумбу и создать новые объекты. Поскольку все объекты есть Тумба в измененном виде, Тумба не может существовать одновременно с ними и её нужно вызывать за пределами континуума.

Дырка тем не менее, сама по себе входит в пространство ВСЁ, а значит все сотворенные в ней объекты будут доступны в Everything, существуя вне времени и пространства текущей вселенной.

После создания всего недостающего, мы делаем Лужу2, где х=-х.
В ней мы Присваиваем переменной Z значение переменной Y, тем самым отражая его ещё и на множество отрицательных чисел, а потом помещаем всё это в ДИГ и испаряем Лужу2.
Далее ВСЁ схлопывается в Тумбу. Что примечательно, Тумба, получившаяся при этом далее используется в Дырке для порождения АСАГАЛа и чисел, но схлопывать её ещё раз не требуется, так как всё, что она при этом породит, будет схлопнуто в неё же вместе с дыркой и ВСЕМ. Что не удивительно, если учесть, что Тумба существует вне времени и вообще какой либо экзистенции.

За сим пока всё, присылайте свои примеры интересных Лужекодов и удачи в постижении этого увлекательного занятия.



Лужеиндукция

Previous post
Up