История изменений

А как ты определяешь информацию и энтропию?

Вот я определил понятие количества бит под аргумент и результат данной функции — в случае аргумента нужны все значения, в количестве равном мощности множества аргумента, вложение в множество строк минимальной достаточной фиксированной длины даёт количество бит (= эта фиксированная длина) равное логарифму этой мощности (округление вверх), для результата нужен только образ функции — логарифм мощности образа функции в вопросе.

f : A -> B — log(|A|) и log(|Im(f)|). Ну офигеть :)

Это даже не определения — вещи так и будут себя вести при любой попытке кодирования.

Но суть в том, что любые утверждения про эти количества сводятся к обычным теоретико-множественным (выкидыванием логарифмов). То есть например — если ты посчитаешь log(|Im(f)|) для сложения, то получишь один лишний бит (по отношению к битности _одного_ из аргументов), то есть, да, куча информации пропадает (аргумента два, информации вдвое больше, пропадает — ты написал пример разбиения), если посчитаешь для умножения — получишь примерно удвоение (тоже относительно одного аргумента), но с недобором — кое-что пропадает (тоже есть эквивалентные разбиения, хотя ближе к пределу, то есть вложению из декартового _произведения_ (раз уж умножение) аргументов). Ну вот так ведут себя функции на множествах — есть свойства которые характеризуют всё что тут происходит (например, наложение обращается (и является соответствием) если есть уникальная обратная, иначе аксиома выбора позволяет выбирать разные варианты возвращений в область определения — их количеством на элементах образа можно численно тонко характеризовать (вместо простого log(|Im(f)|) / log(|A|) <= 1) эту самую неопределённость и потерю информации на разных элементах, а в крайнем случае соответствия-существования-обратной у нас будет просто сохранение количества информации).

Речь только про кольцо

Ну всё равно есть операции возвращения константы, одного из аргументов, минимума/максимума, сложения, умножения, степени... мощности образов которых ведут себя очень по-разному. Понятно, что раз потеря информации характеризуется свойствами функции (тем, насколько она «далека» от вложения), то можно подобрать любую, обеспечив любую потерю (с информацией от нуля до информации в аргументе — тут у меня получается как у Waterlaz :)).

Зная сумму(mod256) и одно из слагаемых мы знаем и второе слагаемое

Мы знаем _только_ результат

Как-то противоречит.

Ну и смысл обсуждать этот случай?

Ну ты сам начал про конкретные сложения и умножения в конкретных конечных кольцах говорить.

А как ты определяешь информацию и энтропию?

Вот я определил понятие количества бит под аргумент и результат данной функции — в случае аргумента нужны все значения, в количестве равном мощности множества аргумента, вложение в множество строк минимальной достаточной фиксированной длины даёт количество бит (= эта фиксированная длина) равное логарифму этой мощности (округление вверх), для результата нужен только образ функции — логарифм мощности образа функции в вопросе.

f : A -> B — log(|A|) и log(|Im(f)|). Ну офигеть :)

Это даже не определения — вещи так и будут себя вести при любой попытке кодирования.

Но суть в том, что любые утверждения про эти количества сводятся к обычным теоретико-множественным (выкидыванием логарифмов). То есть например — если ты посчитаешь log(|Im(f)|) для сложения, то получишь один лишний бит (по отношению к битности _одного_ из аргументов), то есть, да, куча информации пропадает (аргумента два, информации вдвое больше, пропадает — ты написал пример разбиения), если посчитаешь для умножения — получишь примерно удвоение (тоже относительно одного аргумента), но с недобором — кое-что пропадает (тоже есть эквивалентные разбиения, хотя ближе к пределу, то есть вложению из декартового _произведения_ (раз уж умножение) аргументов). Ну вот так ведут себя функции на множествах — есть свойства которые характеризуют всё что тут происходит (например, наложение обращается (и является соответствием) если есть уникальная обратная, иначе аксиома выбора позволяет выбирать разные варианты возвращений в область определения — их количеством на элементах образа можно численно тонко характеризовать (вместо простого log(|Im(f)|) / log(|A|) <= 1) эту самую неопределённость и потерю информации на разных элементах, а в крайнем случае соответствия-существования-обратной у нас будет просто сохранение количества информации).

Речь только про кольцо

Ну всё равно есть операции возвращения константы, одного из аргументов, минимума/максимума, сложения, умножения, степени... мощности образов которых ведут себя очень по-разному. Понятно, что раз потеря информации характеризуется свойствами функции (тем, насколько она «далека» от вложения), то можно подобрать любую, обеспечив любую потерю (с информации от нуля до информации в аргументе — тут у меня получается как у Waterlaz :)).

Зная сумму(mod256) и одно из слагаемых мы знаем и второе слагаемое

Мы знаем _только_ результат

Как-то противоречит.

Ну и смысл обсуждать этот случай?

Ну ты сам начал про конкретные сложения и умножения в конкретных конечных кольцах говорить.

А как ты определяешь информацию и энтропию?

Вот я определил понятие количества бит под аргумент и результат данной функции — в случае аргумента нужны все значения, в количестве равном мощности множества аргумента, вложение в множество строк минимальной достаточной фиксированной длины даёт количество бит (= эта фиксированная длина) равное логарифму этой мощности (округление вверх), для результата нужен только образ функции — логарифм мощности образа функции в вопросе.

f : A -> B — log(|A|) и log(|Im(f)|). Ну офигеть :)

Это даже не определения — вещи так и будут себя вести при любой попытке кодирования.

Но суть в том, что любые утверждения про эти количества сводятся к обычным теоретико-множественным (выкидыванием логарифмов). То есть например — если ты посчитаешь log(|Im(f)|) для сложения, то получишь один лишний бит (по отношению к битности _одного_ из аргументов), то есть, да, куча информации пропадает (аргумента два, информации вдвое больше, пропадает — ты написал пример разбиения), если посчитаешь для умножения — получишь примерно удвоение (тоже относительно одного аргумента), но с недобором — кое-что пропадает (тоже есть эквивалентные разбиения, хотя ближе к пределу, то есть вложению из декартового _произведения_ (раз уж умножение) аргументов). Ну вот так ведут себя функции на множествах — есть свойства которые характеризуют всё что тут происходит (например, наложение обращается (и является соответствием) если есть уникальная обратная, иначе аксиома выбора позволяет выбирать разные варианты возвращений в область определения — их количеством на элементах образа можно численно тонко характеризовать (вместо простого log(|Im(f)|) / log(|A|) <= 1) эту самую неопределённость и потерю информации на разных элементах, а в крайнем случае соответствия-существования-обратной у нас будет просто сохранение количества информации).

Речь только про кольцо

Ну всё равно есть операции возвращения константы, одного из аргументов, минимума/максимума, сложения, умножения, степени... мощности образов которых ведут себя очень по разному. Понятно, что раз потеря информации характеризуется свойствами функции (тем, насколько она «далека» от вложения), то можно подобрать любую, обеспечив любую потерю (с информации от нуля до информации в аргументе — тут у меня получается как у Waterlaz :)).

Зная сумму(mod256) и одно из слагаемых мы знаем и второе слагаемое

Мы знаем _только_ результат

Как-то противоречит.

Ну и смысл обсуждать этот случай?

Ну ты сам начал про конкретные сложения и умножения в конкретных конечных кольцах говорить.

А как ты определяешь информацию и энтропию?

Вот я определил понятие количества бит под аргумент и результат данной функции — в случае аргумента нужны все значения, в количестве равном мощности множества аргумента, вложение в множество строк минимальной достаточной фиксированной длины даёт количество бит (= эта фиксированная длина) равное логарифму этой мощности (округление вверх), для результата нужен только образ функции — логарифм мощности образа функции в вопросе.

f : A -> B — log(|A|) и log(|Im(f)|). Ну офигеть :)

Это даже не определения — вещи так и будут себя вести при любой попытке кодирования.

Но суть в том, что любые утверждения про эти количества сводятся к обычным теоретико-множественным (выкидыванием логарифмов). То есть например — если ты посчитаешь log(|Im(f)|) для сложения, то получишь один лишний бит (по отношению к битности _одного_ из аргументов), то есть, да, куча информации пропадает (аргумента два, информации вдвое больше, пропадает — ты написал пример разбиения), если посчитаешь для умножения — получишь примерно удвоение (тоже относительно одного аргумента), но с недобором — кое-что пропадает (тоже есть эквивалентные разбиения, хотя ближе к пределу, то есть вложению из декартового _произведения_ (раз уж умножение) аргументов). Ну вот так ведут себя функции на множествах — есть свойства которые характеризуют всё что тут происходит (например, наложение обращается (и является соответствием) если есть уникальная обратная, иначе аксиома выбора позволяет выбирать разные варианты возвращений в область определения — их количеством на элементах образа можно численно характеризовать эту самую неопределённость и потерю информации, а в крайнем случае соответствия-существования-обратной у нас будет просто сохранение количества информации).

Речь только про кольцо

Ну всё равно есть операции возвращения константы, одного из аргументов, минимума/максимума, сложения, умножения, степени... мощности образов которых ведут себя очень по разному. Понятно, что раз потеря информации характеризуется свойствами функции (тем, насколько она «далека» от вложения), то можно подобрать любую, обеспечив любую потерю (с информации от нуля до информации в аргументе — тут у меня получается как у Waterlaz :)).

Зная сумму(mod256) и одно из слагаемых мы знаем и второе слагаемое

Мы знаем _только_ результат

Как-то противоречит.

Ну и смысл обсуждать этот случай?

Ну ты сам начал про конкретные сложения и умножения в конкретных конечных кольцах говорить.

А как ты определяешь информацию и энтропию?

Вот я определил понятие количества бит под аргумент и результат данной функции — в случае аргумента нужны все значения, в количестве равном мощности множества аргумента, вложение в множество строк минимальной достаточной фиксированной длины даёт количество бит (= эта фиксированная длина) равное логарифму этой мощности (округление вверх), для результата нужен только образ функции — логарифм мощности образа функции в вопросе.

f : A -> B — log(|A|) и log(|Im(f)|). Ну офигеть :)

Это даже не определения — вещи так и будут себя вести при любой попытке кодирования.

Но суть в том, что любые утверждения про эти количества сводятся к обычным теоретико-множественным (выкидыванием логарифмов). То есть например — если ты посчитаешь log(|Im(f)|) для сложения, то получишь один лишний бит (по отношению к битности _одного_ из аргументов), то есть, да, куча информации пропадает (аргумента два, информации вдвое больше, пропадает — ты написал пример разбиения), если посчитаешь для умножения — получишь примерно удвоение (тоже относительно одного аргумента), но с недобором — кое-что пропадает (тоже есть эквивалентные разбиения, хотя ближе к пределу, то есть вложению из декартового _произведения_ (раз уж умножение) аргументов). Ну вот так ведут себя функции на множествах — есть свойства которые характеризуют всё что тут происходит (например, наложение обращается (и является соответствием) если есть уникальная обратная, иначе аксиома выбора позволяет выбирать разные варианты возвращений в область определений — их количеством на элементах образа можно численно характеризовать эту самую неопределённость и потерю информации, а в крайнем случае соответствия-существование-обратной у нас будет просто сохранение количества информации).

Речь только про кольцо

Ну всё равно есть операции возвращения константы, одного из аргументов, минимума/максимума, сложения, умножения, степени... мощности образов которых ведут себя очень по разному. Понятно, что раз потеря информации характеризуется свойствами функции (тем, насколько она «далека» от вложения), то можно подобрать любую, обеспечив любую потерю (с информации от нуля до информации в аргументе — тут у меня получается как у Waterlaz :)).

Зная сумму(mod256) и одно из слагаемых мы знаем и второе слагаемое

Мы знаем _только_ результат

Как-то противоречит.

Ну и смысл обсуждать этот случай?

Ну ты сам начал про конкретные сложения и умножения в конкретных конечных кольцах говорить.