Refal и ChatGPT 4.0

[Sergei Skorobogatov s.yu.skorobogatov_AT_gmail.com]

Всем привет!

Я тут поразвлекался с четвёртой версией ChatGPT, выдав ей следующее задание:

Please, write a short specification for a new functional programming language. The language should preserve the syntax and semantics of Refal language as much as possible, but every function declaration in it must be typed.

Результат получился довольно забавный, и мне захотелось им поделиться:

Title: TypedRefal - A Typed Functional Programming Language Based on Refal

1. Introduction

TypedRefal is a new functional programming language that aims to preserve the syntax and semantics of the Refal language while introducing static typing to function declarations. This document provides a brief specification of the language, focusing on its syntax, semantics, and type system.

2. Syntax

The syntax of TypedRefal is largely based on the Refal language, with some modifications to accommodate the introduction of types. The basic elements of the language are:

- Identifiers: Identifiers are used to represent variables, functions, and types. They consist of alphanumeric characters and underscores, starting with a letter or underscore.

- Constants: Constants are either integer or string literals.

- Expressions: Expressions are sequences of identifiers, constants, and parentheses, representing function calls and data structures.

- Patterns: Patterns are used to define the input of functions and consist of identifiers, constants, and parentheses.

- Results: Results are used to define the output of functions and consist of expressions.

3. Function Declarations

Function declarations in TypedRefal have the following structure:

```
<Type> <FunctionName> {
  <Pattern> ::= <Result>
  ...
}
```

- `<Type>`: The type of the function, which consists of input and output types separated by an arrow (->). For example, `Int -> String` represents a function that takes an integer as input and returns a string as output.

- `<FunctionName>`: The name of the function, which is an identifier.

- `<Pattern>`: The input pattern of the function, which is matched against the input expression.

- `<Result>`: The result expression, which is returned when the input pattern is matched.

4. Types

TypedRefal introduces a static type system to the Refal language. The basic types in TypedRefal are:

- Int: Represents integer values.

- String: Represents string values.

- List<T>: Represents lists of elements of type T.

- Tuple<T1, T2, ...>: Represents tuples of elements of different types.

- Function<T1, T2>: Represents functions that take an input of type T1 and return a value of type T2.

5. Type Inference

TypedRefal supports type inference, allowing the compiler to automatically deduce the types of expressions and function arguments based on their usage. This reduces the need for explicit type annotations in many cases.

6. Type Checking

TypedRefal performs static type checking at compile-time, ensuring that functions are called with the correct argument types and that their return values are used correctly. This helps catch potential errors early in the development process and improves the safety and reliability of the code.

7. Conclusion

TypedRefal is a functional programming language that extends the Refal language with a static type system, providing improved safety and reliability while preserving the familiar syntax and semantics of Refal. With its strong typing and type inference capabilities, TypedRefal is well-suited for a wide range of functional programming tasks. 

Мне показалось, что данная "спецификация" слишком уж кратка и поверхностна, и я попросил ChatCPT прояснить некоторые моменты:

Please specify the syntax and semantics for TypedRefal expressions, patterns and results. Also write some example programs in TypedRefal.

В итоге всё стало гораздо интереснее, хоть он и позабыл об анонсированной стрелочке в типовых выражениях, а также сильно налажал в грамматике и примерах :-)

8. Expressions

Expressions in TypedRefal are used to represent function calls, data structures, and values. They consist of identifiers, constants, and parentheses. The syntax for expressions is as follows:

```
<expression> ::= <identifier> | <constant> | <function_call> | <list> |tuple>
function_call> ::= <identifier> <expression>*
list> ::= [<expression>*]
<tuple> ::=expression>, <expression>, ...)
```

9. Patterns

Patterns in TypedRefal are used to define the input of functions. They consist of identifiers, constants, and parentheses. The syntax for patterns is as follows:

```
<pattern> ::= <identifier> |constant> | <list_pattern> | <tuple_pattern>
<list_pattern> ::= [<pattern>*]
<tuple_pattern> ::= (<pattern>, <pattern>, ...)
```

10. Results

Results in TypedRefal are used to define the output of functions. They consist of expressions. The syntax for results is as follows:

```
result> ::= <expression>
```

11. Example Programs

Here are some example programs written in TypedRefal:

1. Factorial function:

```TypedRefal
Int factorial(Int n) {
  0 ::= 1
  n ::= n * factorial(n - 1)
}
```

2. Fibonacci function:

```TypedRefal
Int fibonacci(Int n) {
  0 ::= 0
  1 ::= 1
  n ::= fibonacci(n - 1) + fibonacci(n - 2)
}
```

3. Length of a list:

```TypedRefal
Int length(List<A> xs) {
  [] ::= 0
  [x : xs] ::= 1 + length(xs)
}
```

4. Map function:

```TypedRefal
List<B> map(Function<A, B> f, List<A> xs) {
  [] ::= []
  [x : xs] ::= [f(x) : map(f, xs)]
}
```

5. Concatenate two lists:

```TypedRefal
List<A> concat(List<A> xs, List<A> ys) {
  [] ::= ys
  [x : xs] ::= [x : concat(xs, ys)]
}
```

6. Zip two lists into a list of tuples:

```TypedRefal
List<Tuple<A, B>> zip(List<A> xs, List<B> ys) {
  [] ::= []
  [x : xs] [y : ys] ::= [(x, y) : zip(xs, ys)]
}
```

These examples demonstrate the syntax and semantics of TypedRefal expressions, patterns, and results, as well as the use of the type system to ensure correct function calls and data structures.

В общем, ждём GPT-5. Я почти уверен, что оно придумает нам такой Рефал, что земля содрогнётся 😁

С уважением,

Сергей.

[Andrei Klimov andrei_AT_klimov.net]

Да, впечатляет! Сам я еще не научился пользоваться ChatGPT-ом (может, Сергей научит?), а с интересом изучаю диалоги, что выставили другие на просторах интернета.

То, что некий «ИИ» может писать связный текст, хорошо структурированный по теме запроса (как здесь четко воспроизводится структура описания языка), — это, в принципе, может быть: на то он и содержит «базу знаний» как «базу шаблонов». Что удивительно — то, что он (она, оно) понимает задания, сформулированные короткими запросами.

В связи с этим вопрос: Сергей, с какой попытки удалось сформулировать запрос, чтобы получить осмысленный ответ? Сколько «бреда» пришлось забраковать?

Спрашиваю потому, что подозреваю, что всё выставляют удачные варианты беседы с ChatGPT, а муки поиска не показывают. Мои подозрения имеют смысл? 

Андрей

[Sergei Skorobogatov s.yu.skorobogatov_AT_gmail.com]

Запрос удалось сформулировать с первой попытки.

Другое дело, что я ведь на этом не остановился, и вторая попытка принесла гораздо более забавные результаты :-)

Вторая попытка отличалась от первой добавлением следующей фразы:

Please, be extremely precise and pedantic. All parts of the specification should be consistent with each other and contain sample programs.

В результате получился гораздо более симпатичный рефал, без элементов синтаксиса C++. 

Мне, в частности, понравился вот такой пример:

FilterInt: [A] -> [Int] {

[] = []; [s.1<Int> : e.tail] = [s.1 : <FilterInt e.tail>]; [s.1 : e.tail] = <FilterInt e.tail>; }

Здесь мы видим generic-функцию, принимающую на вход произвольный список и возвращающую список целых чисел. При этом "гопота" изобрела гарды по типу в образцах (s.1<Int>), хотя никто её об этом специально не просил. Это, так сказать, творческое осмысление задания: раз попросили добавить в рефал статическую типизацию, значит неплохо бы ещё добавить динамическую проверку типов :-)

Завтра, наверное, попробую ещё раз. Мне пришло в голову, что "гопота", видимо, не просекла, что списки в рефале можно разбирать с любой стороны, и надо бы ей явно об этом напомнить.

чт, 30 мар. 2023 г. в 21:11, Andrei Klimov andrei_AT_klimov.net <re...@botik.ru>:

[Andrei Klimov andrei_AT_klimov.net]

Да-а-а! Пример крутой! Как «оно» «догадалось» построить пример фильтрации по типу?!

Тут уж стоит задуматься: откуда он(о) не просто «знает» про Рефал, а еще «понимает» его, в смысле может содержательно варьировать синтаксис?

Угловые скобки и двоеточие мог позаимствовать из Хаскеля. Но для этого надо «понимать», что это родственные языки!

Пишет выражения внутри [], «подразумевая» не один элемент списка, а его фрагмент. В принципе, это допустимая идея. Кажется, так сделано в Wolfram'овской Mathematica. Кстати, язык Wolfram — это фактически Рефал с синтаксисом, подкрученным под мат-формулы.

Андрей

[Igor Adamovich i.a.adamovich_AT_gmail.com]

По-всему выходит, для того чтобы ИскИн мог разрабатывать программы необходима, но не достаточна, полиглотность.

Но не такая, как в GraalVM и Truffle, а настоящая!

Игорь

[Sergei Skorobogatov s.yu.skorobogatov_AT_gmail.com]

Да-а-а! Пример крутой! Как «оно» «догадалось» построить пример фильтрации по типу?!

Видимо, перенесла из какого-то другого языка программирования. Потому что в книжках по рефалу такого точно нет.

Немножко обидно, что пример всё же не до конца правильный с точки зрения типизации ([A] -> [Int]). Дело в том, что во второй версии спецификации про типовые переменные сказано следующее:

TRefal supports type variables, denoted by a single uppercase letter, e.g., A, B, C, etc. Type variables can be used in function declarations to indicate that the function works with generic types. For example: ``` Identity: A -> A { e.x = e.x; } ```

Поэтому [A], очевидно, означает список, каждый элемент которого имеет тип A. А так как никакой иерархии типов в TRefal, к сожалению, не предусмотрено, то нет и никакой возможности передать в нашу функцию FilterInt гетерогенный список, в котором присутствуют как Int'ы, так и не Int'ы. Тем не менее, я уверен, что если указать "гопоте" на этот недостаток, она быстро придумает какой-нибудь адекватный механизм субтипизации :-)

Тут уж стоит задуматься: откуда он(о) не просто «знает» про Рефал, а еще «понимает» его, в смысле может содержательно варьировать синтаксис?

Видимо, зря мы относили способность содержательно варьировать синтаксис к явным проявлениям высшей нервной деятельности. Оказалось, что этим можно заниматься не приходя в сознание :-)

чт, 30 мар. 2023 г. в 23:03, Andrei Klimov andrei_AT_klimov.net <re...@botik.ru>:

[Anton Korzh anton_AT_korzh.us]

я бы не обижал высшую нейронную сеть а признал что тут произошел метасистемный переход и сотни миллиардов нейронов уже являются довольно высокой стадией нервной деятельности.

Но когда произойдет следующий метасистемный переход и тысячи нейронных сетей соединенных вместе смогут мыслить разумнее нас — я бы уже беспокоился (или радовался)

[Sergei Skorobogatov s.yu.skorobogatov_AT_gmail.com]

Да, впечатляет! Сам я еще не научился пользоваться ChatGPT-ом (может, Сергей научит?), а с интересом изучаю диалоги, что выставили другие на просторах интернета.

Если что, для доступа к ChatGPT я использую сервис https://gpt-chat-bot.ru. Он позволяет одновременно вести несколько диалогов, которые создаются при нажатии на кнопку "Создать тему" в верхнем левом углу страницы. Важно при создании темы в качестве модели выбрать gpt-4 и обязательно поставить галочку "Использовать контекст".

чт, 30 мар. 2023 г. в 21:11, Andrei Klimov andrei_AT_klimov.net <re...@botik.ru>:

Да, впечатляет! Сам я еще не научился пользоваться ChatGPT-ом (может, Сергей научит?), а с интересом изучаю диалоги, что выставили другие на просторах интернета.

[Arkady Klimov arkady.klimov_AT_gmail.com]

Мое первое впечатление было от этого примера, что этого ИИ как "студента" или "научного сотрудника" можно охарактеризовать словами "наглый профан". Наверно преподаватели сталкивались с такими типажами студентов и это довольно неприятно. Они готовы нести всякую правдоподобную наукообразную ахинею, затыкая ею те лакуны, где они что-то не знают или не понимают. При этом ты не можешь сходу отличить, где идет четкое знание, а где "замазанное". Понятно, что преподаватель, понимая свой предмет, сам домысливает до верных утверждений, и на это, собственно, и расчет такого наглеца. Пока мы тут в роли такого препода, который радуется, что слышит нечто правдоподобное, и выуживает смыслы. Допускаю, что создатели этого ИИ как раз на такое и целились, и это им, похоже, удалось. Что, конечно, тоже есть значительное достижение, несомненно.

пт, 31 мар. 2023 г. в 00:05, Sergei Skorobogatov s.yu.skorobogatov_AT_gmail.com <re...@botik.ru>:

[nikolai.kondratiev_AT_gmx.de]

Да, действительно. У меня возникла похожая, но несколько другая ассоциация. Среди моих однокурсников попадались иногда прилежные, но плохо соображающие. Когда они сталкивались с задачей, где нужно было подумать, то они выискивали в своей голове, какую-либо формулу или теорему, где попадались похожие понятие и пытались подставить в нее данные из задачи, хота сама задача совершенно не подходила к теореме.

 

Вообще такой способ действий похож на знаменитую Алису: из текстов диалога состряпать некоторое утверждение.

 

Это все равно впечатляет, но пока нет открытых переменных выражения – это не рефал.

[Sergei M. Abramov abram_AT_botik.ru]

Чтож она(он, оно) про рефал не по-русски то?

Всего доброго,

Сергей Абрамов

[Sergei Skorobogatov s.yu.skorobogatov_AT_gmail.com]

Можно было бы и по-русски, но по-английски меньше расходуется контекст языковой модели, максимальный размер которого в ChatGPT 4.0 ограничен 32 тыс. токенов.

Дело в том, что английский текст при подаче в модель токенизируется по словам, а точнее -- одному английскому слову, как правило, соответствует один или два токена. А русский текст токенизируется даже не по буквам, а по байтам UTF-8. Поэтому порождение русского текста обходится во много раз дороже, чем английского. Ну и максимальный размер диалога на русском языке будет во много раз меньше, чем на английском.

вс, 2 апр. 2023 г. в 15:29, Sergei M. Abramov abram_AT_botik.ru <re...@botik.ru>:

[Andrei Klimov andrei_AT_klimov.net]

вс, 2 апр. 2023 г. в 15:29, Sergei M. Abramov abram_AT_botik.ru <re...@botik.ru>:

Что ж она(он, оно) про рефал не по-русски то?

По-русски он/о/а тоже может (цветом выделены мои запросы): 😜

Расскажи про язык программирования Рефал

Рефал - это язык программирования, созданный в СССР в 1966 году. Он был разработан А. К. Саломаа и М. Я. Райзеном в Институте кибернетики имени В. М. Глушкова в Киеве. Рефал был создан для решения задач символьной обработки, таких как обработка текстов, формул, графов и т.д. Язык имеет мощные средства для работы с регулярными выражениями, синтаксическими деревьями и шаблонами. Основными принципами Рефала являются рекурсия и сопоставление с образцом. Рекурсия позволяет определять функции, которые вызывают сами себя, что упрощает написание кода и повышает его читаемость. Сопоставление с образцом позволяет определять шаблоны, которые могут быть использованы для поиска и замены в тексте. Рефал имеет свой синтаксис, который отличается от синтаксиса большинства других языков программирования. Например, в Рефале нет операторов и скобок, вместо этого используются ключевые слова и символы. Сегодня Рефал не является широко используемым языком программирования, однако он все еще используется в некоторых областях, таких как лингвистика, компьютерная логика и искусственный интеллект.

Приведи пример программы на Рефале

Вот пример программы на Рефале, которая считает факториал числа: $ENTRY FAKTORIAL (N) = $ $ 1 = N \to1>; $ $ N * FAKTORIAL (N - 1) = N > 1 \to <2, 1>; $ $ <2, 1> = FAKTORIAL (N - 1) \to3, 2, 1>; $ $3, 2, 1> = N * FAKTORIAL (N - 1) \to <4>; $ $ <4> = N \to FAKTORIAL; $  

В этой программе мы используем рекурсию для вычисления факториала числа N. Сначала мы проверяем, равно ли N единице, и если да, то возвращаем 1. Затем мы умножаем N на результат вызова функции FAKTORIAL с аргументом (N - 1), если N больше 1. Мы продолжаем рекурсивные вызовы, пока N не станет равным 1, после чего возвращаем результат.

[Andrei Klimov andrei_AT_klimov.net]

Я перевел запрос Сергея Скоробогатова на русский Яндекс-переводчиком, и вот что получилось. Свалился в Хаскель:

Пожалуйста, напишите краткую спецификацию для нового функционального языка программирования. Язык должен максимально сохранять синтаксис и семантику языка Refal, но каждое объявление функции в нем должно быть типизировано.

Название языка: Refal-T Основные особенности: - Синтаксис и семантика языка Refal сохранены - Объявления функций типизированы - Поддержка статической типизации - Поддержка базовых типов данных: целочисленный тип, тип с плавающей точкой, логический тип, символьный тип - Поддержка пользовательских типов данных - Поддержка функций высшего порядка - Поддержка рекурсии и итерации Синтаксис объявления функции: <имя функции> :тип входного параметра 1> -> <тип входного параметра 2> -> ... -> <тип входного параметра n> -> <тип выходного параметра> Пример: Reverse : (List a) -> (List a) Типы данных: - Целочисленный тип: int - Тип с плавающей точкой: float - Логический тип: bool - Символьный тип: char - Пользовательские типы данных: объявляются с помощью ключевого слова type Пример: type List a = Nil | Cons a (List a) Функции высшего порядка: - Поддерживаются функции, которые принимают другие функции в качестве аргументов или возвращают функции в качестве результата Пример: Map : (a -> b) -> (List a) -> (List b) Рекурсия и итерация: - Поддерживаются рекурсивные и итеративные функции Пример: Factorial : int -> int Factorial 0 = 1 Factorial n = n * Factorial (n - 1)

[Sergei M. Abramov abram_AT_botik.ru]

> Можно было бы и по-русски, но по-английски меньше расходуется...

Спасибо! Содержательное знание.

Теперь по сути:

1. Все что увидел -- это поверхносный перевод с одного языка
(Haskell) на другой (гипотетический Рефало-суржик)

2. Конечно, типизация это гораздо серьезнее, чем сказано. И даже не
в смысле детализации.

А в смысле отсутствия важной части: как программист строит свои
собственные типы. В мире типов программист должен иметь возможность
создавать свои конструкторы типов.

Если конструкторы ограничены предопределенными тремя -- [Тип], Тип1 ->
Тип2 и (Тип1,... ТипN),-- то не интересно. Это не язык для
реализации Турчинской цели -- "построение формальных лингвистических
моделелй"

3. Рефал Плюс редкий язык программирования с честной реализацией не
только арности функций, но и коарности. Честной коарности нет в
Хаскелле, например. И в типизированном Рефале лично я это хочу
увидеть.

Это все субъективно. И, конечно, не надо об этом говорить ей (ему,
ему), чтобы не расстраивалась.

Всего доброго,

Сергей Абрамов

[Andrei Klimov andrei_AT_klimov.net]

On Sun, 2 Apr 2023 at 17:30, Sergei M. Abramov abram_AT_botik.ru <re...@botik.ru> wrote:

> Можно было бы и по-русски, но по-английски меньше расходуется...

Спасибо! Содержательное знание.

Да, шум вокруг этой GPT-3,4 явно преувеличен. Я посмотрел кое-то ролики лидера OpenAI: хорошо ведет рекламную кампанию. На вопросы, которые он задает GPT во время презентации, та отвечает неплохо. Естественно, возникает обоснованное подозрение, что он готовился к презентации. А как же иначе? Мы же все готовимся, примеры тщательно подбираем... 😆

Я попробовал воспользоваться ею для подбора литературы, на что приходится тратить много время, готовя обзоры по проектам, тема которых не своя. Для проверки адекватности запросил по знакомой теме:

---

Что такое суперкомпиляция?

Суперкомпиляция - это метод автоматической оптимизации программ, который позволяетлучшить их производительность и эффективность. Он основан на анализе и преобразовании кода программы, с целью устранения избыточных вычислений и улучшения структуры программы. Суперкомпиляция используется в различных областях, включая компиляцию, интерпретацию, анализ и оптимизацию программного кода.

Посоветуй свежие статьи по суперкомпиляции?

К сожалению, я не могу дать рекомендации по свежим статьям по суперкомпиляции, так как я не имею возможности искать и анализировать последние научные публикации. Однако, я могу порекомендовать некоторые классические статьи по суперкомпиляции, которые могут быть полезными для изучения этой темы: 1. "The essence of compiling with continuations" (Daniel P. Friedman and David S. Wise, 1976) 2. "A tutorial on the universality and expressiveness of fold" (Neil D. Jones, 1995) 3. "Partial evaluation and automatic program generation" (Neil D. Jones, Carsten K. Gomard, and Peter Sestoft, 1993) 4. "The essence of supercompilation" (Vladimir V. Kirillov, 1998) 5. "Supercompilation: Ideas and Methods" (Sergei A. Romanenko, 2001) Эти статьи могут помочь в пониманииновных концепций и методов суперкомпиляции.

---

См. что я подчеркнул. Тепло, но не горячо. Все равно надо проверять адекватность ответов и фильтровать ошибки. Статья 4 с этим автором не прогугливается. Так что пока не видно, чтобы могла сократить труд в поиске научной информации. Потом запросил по новой для меня теме, которую осваивал в прошлом году и подбирал литературу. Дала десяток статей и книг, содержащих в заголовке название темы, которую я указал. Ну, такое я и сам делаю.

И для развлечения:

---

В чем смысл жизни?

Как искусственный интеллект, я не могу иметь личного мнения о смысле жизни. Однако, существует множество философских и религиозных трактовок этого вопроса. Некоторые люди считают, что смысл жизни заключается в достижении счастья, любви и удовлетворения. Другие считают, что смысл жизни связан с духовным развитием и поиском истины. Есть также те, кто считает, что смысл жизни заключается в помощи другим и создании лучшего мира. В конечном счете, каждый человек находит свой собственный смысл жизни в зависимости от своих убеждений, ценностей и жизненного опыта.

---

Андрей

[Andrei Klimov klimov_AT_keldysh.ru]

Сергей, добрый вечер!

Поскольку вы не в списке рассылки, ваше письмо получил только я — администратор. (У нас такая строгость, так как иначе refal@botik будет сильно заспамлен.) Хорошо, что я заметил ваше письме в длинном треде. Сначала воспроизвожу ваше письме для всех, а ниже отвечаю.

On Fri, Mar 31, 2023 at 2:44 PM <mec...@scico.botik.ru> wrote:

> On Thu, 30 Mar 2023 at 14:57, Sergei Skorobogatov
> s.yu.skorobogatov_AT_gmail.com [1] <re...@botik.ru> wrote:
>
> Всем привет!
>
> Я тут поразвлекался с четвёртой
> версией ChatGPT, выдав ей следующее
> задание:Please, write a short specification for a new
> functional programming language. The language should preserve the
> syntax and semantics of Refal language as much as possible, but every
> function declaration in it must be typed.
>
> Результат получился довольно забавный, и мне захотелось им поделиться:
>
> Title: TypedRefal - A Typed Functional Programming Language Based on
> Refal
>

> [..]


Зачем задавать такие сложные философские вопросы?
Этому ИИ надо задать для начала простой вопрос. Например такой.

Вот функция  rev,  написанная на Рефале, она переворачивает список:
   rev = ;
   rev t.x eX =  <rev eX> tx;

(не помню, как пишется).
Верно ли, что для любого eX  (<rev <rev eX>> == eX)
?
Можно ещё спросить про доказательство.
?

-----------------
Сергей Мешвелиани
(я не в списке, мне переслал письмо Андрей Немытых)

Пожалуйста, вот результат (зеленым мой запрос, потом ее ответ):

---

Вот функция  rev,  написанная на Рефале, которая переворачивает список:
 rev { = ;
   t.x e.X =  <rev e.X> t.x;
}

Верно ли, что для любого eX: <rev <rev eX>> равно eX

Да, верно. Функция rev переворачивает список, а двойной вызов rev дважды переворачивает список, то есть возвращает его в исходном порядке. Таким образом, для любого списка eX, <rev <rev eX>> вернет исходный список eX.

---

 

Я этого не ожидал, полагая, что оно не умеет математически доказывать. Но все-таки подозреваю здесь подвох в том, что оно не «поняло» задачу, а где-то «списало» ответ.

Еще подумал, что оно отреагировало на слова «которая переворачивает список» и списало ответ по ним. Повторил запрос, убрав эти слова. Правда, как пишут, оно учитывает контекст разговора и эксперимент нечистый. Но все-так смотрим:

---

Вот функция  rev,  написанная на Рефале:
 rev { = ;
   t.x e.X =  <rev e.X> t.x;
}

Верно ли, что для любого eX: <rev <rev eX>> равно eX

Да, это верно. Функция rev рекурсивно переворачивает список e.X, помещая каждый элемент в начало нового списка t.x. Переворачивание списка дважды приводит к возвращению исходного списка, так как каждый элемент будет перемещен в начало списка дважды, в исходном порядке. Таким образом, для любого e.X, <rev <revX>> будет равно eX.

---

В комментарии оно переврало семантику функции (см. подчеркнутое), но объяснило более подробно. Теперь попытаемся сбить с толку:

---

Вот функция rev, написанная на Рефале: rev { = ; t.x e.X = t.x <rev e.X>; } Верно ли, что для любого eX: <rev eX> равно eX ?

Нет, это не всегда верно. Например, если eX равно "abc", то <rev eX> будет равно "cba".

---

Соврало. Видно, что отреагировало на название функции, отождествив его со «знанием» из какого-то учебника.

Ставим еще эксперимент, заменив имя функции:

---

Вот функция F, написанная на Рефале: F { = ; t.x e.X = t.x <F e.X>; } Верно ли, что для любого eX: <F eX> равно eX ?

Нет, это не верно. Функция F применяет рекурсивно функцию <F> ко всем элементам списка e.X, и возвращает список, в котором каждый элемент заменен на результат применения <F>. Если список e.X пустой, то результатом будет пустой список. Если список не пустой, то результатом будет список, в котором каждый элемент заменен на e.X. Например, если e.X = (1 2 3), тоF e.X> вернет (e.X e.X e.X), а не e.X.

---

Хоть ответ не верен, но рассуждение занятное. Оно пытается объяснить ответ и запутывается, хотя и «понимает», что речь о потермовой обработке, что не совсем тривиально.

Ставим еще два эксперимента:

---

Вот функция F, написанная на Рефале: F { = ; t.x e.X = <F e.X>; } Верно ли, что для любого eX: <F eX> равно eX ?

Нет, это неверно. Функция F рекурсивно вызывает саму себя с аргументом e.X, что может привести к бесконечной рекурсии. Если F вызывается с аргументом, который не является списком, то она вернет пустой список. Если F вызывается с непустым списком, то она вернет список, состоящий из рекурсивного вызова F с первым элементом списка в качестве аргумента. Таким образом,F eX> может быть равно eX только если eX является пустым списком или списком из одного элемента.

Вот функция F, написанная на Рефале: F { = ; t.x e.X = <F e.X>; } Верно ли, что для любого eX: <F eX> равно пустому выражению ?

Нет, это не верно. Функция F бескечно рекурсивна и будет вызываться до тех пор, пока не будет достигнута максимальная глубина рекурсии или не будет достигнутто другая остановочная точка. Если eX содержит какие-то элементы, то <F eX> будет содержать вызов функции F с другими элементами, и так далее, пока не будет достигнута остановочная точка. Поэтому <F eX> не всегда будет равно пустому выражению.

---

Ух ты! На первый запрос ответило правильно. А на второй запуталось. Занятно, что вовлекло понятия «максимальная глубина рекурсии» и «остановочная точк» (где оно услышало слово «остановочная»?).

Я заподозрил, что оно не поняло слово «выражение», так как в проедыдущих ответах употребляло слово «список». Заменим «пустое выражение» на «пустой список»:

---

Вот функция F, написанная на Рефале: F { = ; t.x e.X = <F e.X>; } Верно ли, что для любого eX: <F eX> равно пустому списку?

Нет, это неверно. Функция F рекурсивно вызывает себя для каждого элемента списка e.X, поэтому результат будет зависеть от того, что содержится в e.X. Если e.X пустой список, то результатом будет пустой список. Однако, если e.X содержит другие списки, то результат может быть непустым. Например, если e.X = (1 (2 3) 4), то <F e.X> будет равно ((()) (() ()) (() () ()) (() ())).

---

Врет, но врет занятно. ИНтересно, откуда у него такие ассоциации: из каких учебников, от каких примеров, на каких языках?

На жаргоне спецов по ИИ это называется «галлюцинациями». Уже появились заметки с заголовками типа: «Как избегать галлюцинации у GPT?».

И последний эксперимент на закуску. Подумал: «А хорошо ли оно понимает синтаксис Рефала?» — и убрал точки в переменных. Ожидал тот же самый ответ, но...

---

Вот функция F, написанная на Рефале: F { = ; tx eX = <F eX>; } Верно ли, что для любого eX: <F eX> равно пустому списку?

Нет, это неверно. Функция F бесконечно рекурсивна, поэтому ее выполнение не завершится для любого входного значения eX. Если бы функция F завершалась для любого eX, тоF eX> действительно было бы пустым списком, так как функция F не содержит никакой логики и просто возвращает пустой список. Однако, из-за бесконечной рекурсии, это не верно.

---

Ответ неверный, но теперь рассуждение выглядит разумным (не совсем галлюцинация): видно, где этот «студент» провирается. Привлечь соображение о бесконечной рекурсии — это нетривиально!

Ладно, на сегодня хватит. Я и так замучил вас длинным протоколом. 

Андрей

[Sergei Skorobogatov s.yu.skorobogatov_AT_gmail.com]

Повторил ваш эксперимент, заменив рефал на питон. (Мой запрос -- зелёный, ответ ChatGPT -- синий).

Вот функция  f,  написанная на языке Python:
```
def f(a):
    return f(a[1:]) if a else []
```
Верно ли, что для любого a: f(a) равно пустому списку?

Да, верно. Функция f(a) рекурсивно удаляет первый элемент списка a до тех пор, пока список не станет пустым, и возвращает пустой список.

Заметно, что питон ей знаком гораздо лучше рефала.

А теперь с переворачиванием списка:

Вот функция  f,  написанная на языке Python:
```
def f(a):
    return f(a[1:]) + [a[0]] if a else []
```
Верно ли, что для любого a: f(f(a)) равно a?

Да, верно. Функция f(a) переворачивает список a, и вызывая её дважды, мы получаем исходный список.

Давайте разберёмся, как работает функция f(a). Если список a пуст, функция возвращает пустой список. Если список a не пуст, функция рекурсивно вызывает себя для хвоста списка a (a[1:]) и добавляет голову списка a (a[0]) в конец результата. Таким образом, функция переворачивает список a.

Теперь, если мы вызовем функцию f дважды, то есть f(f(a)), то получим следующее:

1. Первый вызов f(a) переворачивает список a.
2. Второй вызов f(f(a)) переворачивает результат первого вызова, то есть переворачивает перевёрнутый список a.

В итоге мы получаем исходный список a, так как двойное переворачивание списка равно самому списку.

И напоследок вот такая бомба:

Вот функция  f,  написанная на языке Python:
```
def f(a: List[int]) -> bool:
    return len(a) == 0 or a[0:-1] == a[1:]
```
Что надо передать функции f в качестве аргумента, чтобы она вернула True?

Функция `f` принимает список целых чисел `a` и возвращает `True` в двух случаях:

1. Если список `a` пустой (длина списка равна 0).
2. Если все элементы списка `a`, кроме последнего, равны всем элементам списка `a`, начиная со второго элемента. В других словах, если все элементы списка `a` одинаковые.

Примеры аргументов, при которых функция вернет `True`:

1. `[]` - пустой список.
2. `[1, 1, 1]` - список, состоящий из одинаковых элементов.
3. `[42, 42, 42, 42]` - еще один список с одинаковыми элементами.

Не очень гладко с точки зрения русского языка (выражение "в других словах"), но ответ совершенно правильный.

вс, 2 апр. 2023 г. в 23:51, Andrei Klimov klimov_AT_keldysh.ru <re...@botik.ru>:

[Andrei Klimov andrei_AT_klimov.net]

Сергей, спасибо! 

Да, впечатляет, как оно умудряется «понять» код и прокомментировать его! Вот за этим уже просматривается практическое значение: 

Как считается, программисты тратят больше 70% своего времени, изучая чужой код, в который потом делают вставки для реализации нового функционала. А при освоении новой системы, я бы сказал по своему опыту, и все 90%+. Важные системы должны поставляться с документацией о внутреннем устройстве. Ладно, что документация подчас плохая: если очень надо, можно «выжать» документацию из разработчиков с помощью дополнительного штата технических писателей. А основная проблема, что документация часто расходится с кодом, который убегает вперед в быстром развитии на потребу пользователям. 

Представим такую технологию работы: Комментарии к программе и документация о ее устройстве «наговариваются» Chat'у GPT, чтобы кроме общего знания и умения объяснять код, оно владело особенностями данной системы и умело отвечать на вопросы о конкретном коде. После того, как код изменяется (как правило, не в слишком революционных пределах), оно само сможет комментировать измененных код без дополнительного обучения или с минимумом оного. После рефакторинга программист может поговорить с ним и, убедившись, что оно правильно «поняло» новый код, завершить работу или наговорить уточнения.

А для новых пользователей «ИИ», обученный на данную систему, вообще бесценен. У разных людей возникают разные вопросы: кто-то буксует уже на вопросе, как инсталлировать, а кого-то сразу волнует, какие глубокие фичи есть у системы. Я бы с удовольствием начинал освоение с бесед с таким «ИИ». Сейчас ищешь туториалы в виде текстов с примерами или роликами на Ютубе. Уже на это уходит много времени, пока найдешь то, что отвечает на твои вопросы (которые еще нужно осознать). А в такой беседе быстро выйдешь на информацию, интересующую тебя лично.

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

Андрей

[A N a_nevod_AT_mail.ru]

Семантическая модель и база по Python действительно хорошая, но в конечном счёте это всё-таки пока-что студент, который пытается угадать, что от него хочет преподаватель.

 

Мои запросы — серым, ответы — на зелёном фоне.

Вот функция f, написанная на языке Python: ``` def f(a): return f(a[1:]) if a else [] ``` Верно ли, что на непустом списке, состоящем из списков, f уходит в бесконечный цикл?

 

Да, верно. Функция f рекурсивно вызывает сама себя с аргументом a[1:], который является срезом исходного списка a, начиная со второго элемента. Если a состоит из списков, то a[1:] также будет непустым списком из списков, и функция будет вызывать сама себя бесконечно, так как условие a не будет равным пустому списку.

 

Видно, что фейл произошёл на понятии рекурсии.

Вот функция f, написанная на языке Python: ``` def f(a): return f(a[1:]) + [a[0]] if a else [] ``` Верно ли, что для любого a: f(f(f(a))) равно a?

 

 

 

Да, верно. Функция f(a) реверсирует список a, то есть меняет порядок его элементов на обратный. Если применить эту функцию три раза подряд, список вернется к исходному порядку. Давайте рассмотрим это на примере: ``` a = [1, 2, 3, 4, 5] f(a) = [5, 4, 3, 2, 1] f(f(a)) = f([5, 4, 3, 2, 1]) = [1, 2, 3, 4, 5] f(f(f(a))) = f([1, 2, 3, 4, 5]) = [1, 2, 3, 4, 5] ``` Таким образом, f(f(f(a))) = a для любого списка a.

Здесь это тоже видно, фейл на втором рекурсивном вызове.

 

Верно ли, что регулярное выражение `^[A-Z]*[a-z]$` сопоставляется с любой последовательностью латинских букв?

 

 

 

Нет, это не верно. Регулярное выражение `^[A-Z]*[a-z]$` сопоставляется с последовательностью латинских букв, которая начинается с нуля или более заглавных букв (A-Z) и заканчивается одной строчной буквой (a-z). Это означает, что оно не будет сопоставляться с последовательностями, состоящими только из заглавных букв или последовательностями, в которых строчные и заглавные буквы чередуются.

 

 

 

 

Базовые вещи, которые есть везде и не требуют рекурсивного анализа, он понимает правильно. Ок!

 

Верно ли, что регулярное выражение `^[A-Z]*[a-z]*[A-Z]*[a-z]*$` сопоставляется с любой последовательностью латинских букв?

 

 

 

Верно, данное регулярное выражение сопоставляется с любой последовательностью латинских букв, состоящей из букв верхнего и нижнего регистра, расположенных в любом порядке. Оно состоит из следующих частей: - `^` - начало строки - `[A-Z]*` - ноль или более символов верхнего регистра - `[a-z]*` - ноль или более символов нижнего регистра - `[A-Z]*` - ноль или более символов верхнего регистра - `[a-z]*` - ноль или более символов нижнего регистра - `$` - конец строки Таким образом, данное выражение будет сопоставляться с любой строкой, состоящей из латинских букв верхнего и нижнего регистра, расположенных в любом порядке.

 

А вот тут потребовался анализ на шаг дальше, и наблюдаем картину «студент сочиняет на ходу».

 

Это замечательный подсказчик, если знать, что именно требуется, но если «плавать» в области или есть какие-то тонкости — пока что StackOverflow никуда не девается. 

 

Посмотрим, подружатся ли с рекурсией новые когнитивные модели...

 

 

 

Понедельник, 3 апреля 2023, 13:29 +03:00 от Sergei Skorobogatov s.yu.skorobogatov_AT_gmail.com <re...@botik.ru>:
 

вс, 2 апр. 2023г. в 23:51, Andrei Klimov klimov_AT_keldysh.ru <re...@botik.ru>:

[Sergei Skorobogatov s.yu.skorobogatov_AT_gmail.com]

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

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

Я тут провёл такой эксперимент -- дал модели пример подробного объяснения работы рефал-программы, а потом попросил так же точно объяснить работу другой программы. Вот, что получилось (мои запросы -- зелёный цвет, ответы ChatGPT -- синий цвет):

Here is a function in Refal language:
```
f {
    = ;
    t.1 e.2 = <f e.2>;
}
```

Someone explains, how this function works:
1. Function `f` has two sentences:
    * first sentence states, that if we pass empty expression to function `f`, it will return empty expression;
    * pattern in the left side of the second sentence means, that we must bind variable `t.1` to the first term of an expression, passed to function `f`, and then bind variable `e.2` to the rest terms of the expression.
2. If we call function `f` with empty expression, this expression will satisfy the pattern in the first sentence, and the function will return empty sentence.
3. If we call function `f` with non-empty expression (e.g. `<f 10 20 30>`), then this expression will satisfy the pattern in the second sentence, and will be split into two parts -- first term (10) will go to the variable `t.1`, and other terms (20 and 30) will go to the variable `e.2`. Then, as it is described at the right side of the second sentence, function `f` will be called recursively with the value of variable `e.2` as its argument.
4. We see that at every level of recursion the argument passed to function `f` gets shorter by one term. So at some moment it will become empty, and the first sentence of function `f` will fire, returning the empty sentence as a result.
5. Therefore, function `f` always returns empty expression.

Please, give the same explanation of how the following function `g` works:
```
 g {
   = ;
   t.x e.X =  <g e.X> t.x;
}
```

1. Function `g` has two sentences:
    * The first sentence states that if we pass an empty expression to function `g`, it will return an empty expression.
    * The pattern in the left side of the second sentence means that we must bind variable `t.x` to the first term of an expression passed to function `g`, and then bind variable `e.X` to the rest of the terms in the expression.
2. If we call function `g` with an empty expression, this expression will satisfy the pattern in the first sentence, and the function will return an empty expression.
3. If we call function `g` with a non-empty expression (e.g. `<g 10 20 30>`), then this expression will satisfy the pattern in the second sentence, and will be split into two parts -- the first term (10) will go to the variable `t.x`, and the other terms (20 and 30) will go to the variable `e.X`. Then, as it is described on the right side of the second sentence, function `g` will be called recursively with the value of variable `e.X` as its argument, and the result of this recursive call will be followed by the value of variable `t.x`.
4. We see that at every level of recursion, the argument passed to function `g` gets shorter by one term. So at some moment, it will become empty, and the first sentence of function `g` will fire, returning the empty expression as a result. However, unlike function `f`, function `g` appends the value of `t.x` to the result of the recursive call at each level of recursion.
5. Therefore, function `g` reverses the input expression. For example, if we call `<g 10 20 30>`, the function will return the expression `30 20 10`.

Как видим, ChatGPT воспроизвела мои рассуждения, подкорректировав их под другую функцию, и в результате догадалась, что функция переворачивает выражение.

Теперь у ChatGPT можно спросить, что будет, если применить функцию к результату применения этой же функции:

Imagine, that we call function `g` twice: `<g <g X>>`, where X denotes some expression.
Explain, what expression will function `g` return.

When we call function `g` twice as `<g <g X>>`, the following steps occur:

1. The outer call to function `g` receives the result of the inner call to function `g` as its argument. Let's first consider the inner call `<g X>`.
2. As we explained earlier, function `g` reverses the input expression. So, the inner call `<g X>` will return the reversed expression of X. Let's denote this reversed expression as Y.
3. Now, the outer call to function `g` receives Y as its argument. Since Y is the reversed expression of X, calling `g` again with Y as the argument will reverse Y.
4. As function `g` reverses its input expression, the outer callg Y>` will return the reversed expression of Y, which is the original expression X.

Therefore, when we call function `g` twice asg <g X>>`, it returns the original expression X. This is because the two reversals effectively cancel each other out, resulting in the original input expression.

В итоге мы получаем (почти, с точностью до опечаток) правильный ответ :-)

ср, 5 апр. 2023 г. в 17:02, A N a_nevod_AT_mail.ru <re...@botik.ru>:

[A N a_nevod_AT_mail.ru]

Неохота выкладывать всю переписку, но в общем в достаточно длинном контексте ChatGPT подсказал регулярку `^([A-Za-z]*)+$` как регулярку, которая принимает любое выражение из букв, и затем упростил её до `^([A-Za-z])+$` , когда было уточнение про два квантификатора. Затем через некоторую боль удалось его навести на то, что они не эквивалентны, но без подсказок про пустую строку увы, этого сделать не получилось. 

 

Возникает новый тип задач для студентов: ввести такой запрос для ChatGPT, чтобы он дал правильный ответ. Если студент хоть немножко плавает и модель не типа Hello World, а всё-таки требующая хоть минимального анализа на один-два шага (пусть и без рекурсии), то ему будет не особенно просто добиться чистого результата (с учётом контекста; без учёта — не знаю, вообще возможно ли за адекватное число попыток). Заодно хорошо прочувствуют, что в искусственном интеллекте нечего делать без естественного интеллекта постановщика задач, и как «приятно» принимать экзамен по много часов, в попытках выудить из их семантической модели более глубокие связи.  

 

 

 

 

Среда, 5 апреля 2023, 19:32 +03:00 от Sergei Skorobogatov s.yu.skorobogatov_AT_gmail.com <re...@botik.ru>:
 

ср, 5 апр. 2023г. в 17:02, A N a_nevod_AT_mail.ru <re...@botik.ru>:

[Sergei M. Abramov abram_AT_botik.ru]

А еще в рефале есть сконки. Интересно, как зверушке зайдет такая функция?

f {
= ;
s.1 e.2 = <f e.2> s.1
(e.1) e.2 = <f e.2> (<f e.1>);
}

Ну, там стандартные вопросы: чему равно <f <f e.x>> и т.п.

Всего доброго,

Сергей Абрамов


Вы писали 05 апреля 2023 г., 19:31:15:

> Вот функция  rev,  написанная на Рефале, которая переворачивает список:
>  rev { = ;
>    t.x e.X =  <rev e.X> t.x;
> }

> Верно ли, что для любого eX: <rev <rev eX>> равно eX

> Да, верно. Функция rev переворачивает список, а двойной вызов rev
> дважды переворачивает список, то есть возвращает его в исходном
> порядке. Таким образом, для любого списка eX, <rev <rev eX>> вернет исходный список eX.


>  

> Я этого не ожидал, полагая, что оно не умеет математически
> доказывать. Но все-таки подозреваю здесь подвох в том, что оно не
> «поняло» задачу, а где-то «списало» ответ.

> Еще подумал, что оно отреагировало на слова «которая переворачивает
> список» и списало ответ по ним. Повторил запрос, убрав эти слова.
> Правда, как пишут, оно учитывает контекст разговора и эксперимент нечистый. Но все-так смотрим:
>  

> Вот функция  rev,  написанная на Рефале:
>  rev { = ;
>    t.x e.X =  <rev e.X> t.x;
> }

> Верно ли, что для любого eX: <rev <rev eX>> равно eX

> Да, это верно. Функция rev рекурсивно переворачивает список e.X,
> помещая каждый элемент в начало нового списка t.x. Переворачивание
> списка дважды приводит к возвращению исходного списка, так как
> каждый элемент будет перемещен в начало списка дважды, в исходном
> порядке. Таким образом, для любого e.X, <rev <revX>> будет равно eX.

> В комментарии оно переврало семантику функции (см. подчеркнутое),
> но объяснило более подробно. Теперь попытаемся сбить с толку:
>  

> Вот функция rev, написанная на Рефале: rev { = ; t.x e.X = t.x <rev
> e.X>; } Верно ли, что для любого eX: <rev eX> равно eX ?
>  
>  
>  
> Нет, это не всегда верно. Например, если eX равно "abc", то <rev eX> будет равно "cba".

> Соврало. Видно, что отреагировало на название функции, отождествив
> его со «знанием» из какого-то учебника.

> Ставим еще эксперимент, заменив имя функции:
>  

> Вот функция F, написанная на Рефале: F { = ; t.x e.X = t.x <F e.X>;
> } Верно ли, что для любого eX: <F eX> равно eX ?
>  
>  
>  
> Нет, это не верно. Функция F применяет рекурсивно функцию <F> ко
> всем элементам списка e.X, и возвращает список, в котором каждый
> элемент заменен на результат применения <F>. Если список e.X пустой,
> то результатом будет пустой список. Если список не пустой, то
> результатом будет список, в котором каждый элемент заменен на e.X.
> Например, если e.X = (1 2 3), тоF e.X> вернет (e.X e.X e.X), а не e.X.

> Хоть ответ не верен, но рассуждение занятное. Оно пытается
> объяснить ответ и запутывается, хотя и «понимает», что речь о
> потермовой обработке, что не совсем тривиально.

> Ставим еще два эксперимента:
>  

> Вот функция F, написанная на Рефале: F { = ; t.x e.X = <F e.X>; }
> Верно ли, что для любого eX: <F eX> равно eX ?
>  
>  
>  
> Нет, это неверно. Функция F рекурсивно вызывает саму себя с
> аргументом e.X, что может привести к бесконечной рекурсии. Если F
> вызывается с аргументом, который не является списком, то она вернет
> пустой список. Если F вызывается с непустым списком, то она вернет
> список, состоящий из рекурсивного вызова F с первым элементом списка
> в качестве аргумента. Таким образом,F eX> может быть равно eX только
> если eX является пустым списком или списком из одного элемента.
>  
>  
>  
> Вот функция F, написанная на Рефале: F { = ; t.x e.X = <F e.X>; }
> Верно ли, что для любого eX: <F eX> равно пустому выражению ?
>  
>  
>  
> Нет, это не верно. Функция F бескечно рекурсивна и будет вызываться
> до тех пор, пока не будет достигнута максимальная глубина рекурсии
> или не будет достигнутто другая остановочная точка. Если eX содержит
> какие-то элементы, то <F eX> будет содержать вызов функции F с
> другими элементами, и так далее, пока не будет достигнута
> остановочная точка. Поэтому <F eX> не всегда будет равно пустому выражению.

> Ух ты! На первый запрос ответило правильно. А на второй запуталось.
> Занятно, что вовлекло понятия «максимальная глубина рекурсии» и
> «остановочная точк» (где оно услышало слово «остановочная»?).

> Я заподозрил, что оно не поняло слово «выражение», так как в
> проедыдущих ответах употребляло слово «список». Заменим «пустое выражение» на «пустой список»:
>  

> Вот функция F, написанная на Рефале: F { = ; t.x e.X = <F e.X>; }
> Верно ли, что для любого eX: <F eX> равно пустому списку?
>  
>  
>  
> Нет, это неверно. Функция F рекурсивно вызывает себя для каждого
> элемента списка e.X, поэтому результат будет зависеть от того, что
> содержится в e.X. Если e.X пустой список, то результатом будет
> пустой список. Однако, если e.X содержит другие списки, то результат
> может быть непустым. Например, если e.X = (1 (2 3) 4), то <F e.X>
> будет равно ((()) (() ()) (() () ()) (() ())).


>  

> Врет, но врет занятно. ИНтересно, откуда у него такие ассоциации:
> из каких учебников, от каких примеров, на каких языках?

> На жаргоне спецов по ИИ это называется «галлюцинациями». Уже
> появились заметки с заголовками типа: «Как избегать галлюцинации у GPT?».
>  
> И последний эксперимент на закуску. Подумал: «А хорошо ли оно
> понимает синтаксис Рефала?» — и убрал точки в переменных. Ожидал тот же самый ответ, но...
>  

> Вот функция F, написанная на Рефале: F { = ; tx eX = <F eX>; }
> Верно ли, что для любого eX: <F eX> равно пустому списку?
>  
>  
>  
> Нет, это неверно. Функция F бесконечно рекурсивна, поэтому ее
> выполнение не завершится для любого входного значения eX. Если бы
> функция F завершалась для любого eX, тоF eX> действительно было бы
> пустым списком, так как функция F не содержит никакой логики и
> просто возвращает пустой список. Однако, из-за бесконечной рекурсии, это не верно.


>  

> Ответ неверный, но теперь рассуждение выглядит разумным (не совсем
> галлюцинация): видно, где этот «студент» провирается. Привлечь
> соображение о бесконечной рекурсии — это нетривиально!
>  
> Ладно, на сегодня хватит. Я и так замучил вас длинным протоколом. 

> Андрей


>  

--
С уважением,
Абрамов С.М. mailto:ab...@botik.ru

[Andrei Klimov andrei_AT_klimov.net]

On Thu, 6 Apr 2023 at 15:01, Sergei M. Abramov abram_AT_botik.ru <re...@botik.ru> wrote:

А еще в рефале есть сконки. Интересно, как зверушке зайдет такая функция?

f {
 = ;
 s.1 e.2 = <f e.2> s.1
 (e.1) e.2 = <f e.2> (<f e.1>);
}

Ну, там стандартные вопросы: чему равно <f <f e.x>> и т.п.

См. ниже результат. Видно, что скобки оно НЕ понимает.

Занятно, что как выявилось еще в предыдущих экспериментах, оно по-разному понимает код рефала с точками и без точек (желтый запрос и зеленый ответ). Наверно, оно учило диалекты Рефала по разным учебникам с разными примерами.

Андрей

Дано следующее определение функции f на языке программирования Рефал: ``` f { = ; s.1 e.2 = <f e.2> s.1 (e.1) e.2 = <f e.2> (<f e.1>); } ``` Верно ли, что <f<f<e.x>> == e.x ?

Для ответа на этот вопрос нужно выполнить несколько шагов вычисления функции f: 1. <f<fe.x>>> 2.ffe.x>>> 3. <ffe.x>>f <e.x>>> 4. <f <f <e.x>> <fe.x>> <> 5. <f <e.x>> <f <fe.x>>> 6. <f <e.x>>ffe.x>> <fe.x>>> 7. <f <e.x>>f <fe.x>> <f <e.x>> <> 8. <f <fe.x>>> 9. <f <fe.x>> <> 10. <fe.x>> Таким образом, мы получили <f<fe.x>> = <fe.x>>. Но это не равно e.x в общем случае. Например, если e.x = (1), тоfe.x>> = <f<(1)>> =f>> =>, тогда как e.x = (1).

Дано следующее определение функции f на языке программирования Рефал: ``` f { = ; s1 e2 = <f e2> s1 (e1) e2 = <f e2> (<f e1>); } ``` Верно ли, что <f<f<ex>> == ex ?

Для ответа на этот вопрос необходимо понимать, как работает функция f. Если на вход функции f подается пустой список (первое правило), то она просто возвращает этот список без изменений. Если на вход функции f подается список, состоящий из одного элемента (второе правило), то она рекурсивно вызывает себя для второго элемента списка и возвращает результат, который получается из второго элемента списка и результата рекурсивного вызова функции f для него, помещенных в новый список. Теперь рассмотрим выражениеf<fex>>. Сначала происходит вызов функции f для внутреннего выражения f<ex>. Согласно второму правилу функции f, результатом этого вызова будет список, состоящий из двух элементов: результата вызова функции f для ex и самого ex, помещенных в новый список. То есть получится список, эквивалентный выражению <f ex> ex. Теперь происходит вызов функции f для этого списка. Согласно второму правилу функции f, результатом этого вызова будет список, состоящий из двух элементов: результата вызова функции f для ex и списка, содержащего результат вызова функции f для ex и сам ex, помещенных в новый список. То есть получится список, эквивалентный выражению <f ex> (<f ex> ex). Таким образом,f<fex>> эквивалентно выражению <f ex> (<f ex> ex).  

Ответ на вопрос зависит от того, какое значение имеет ex. Если ex является пустым списком, тоf<fex>> будет эквивалентно пустому списку. Если ex является любым другим списком, то <f<f<ex>> не будет эквивалентно ex.

 

[Sergei M. Abramov abram_AT_botik.ru]

> См. ниже результат. Видно, что скобки оно НЕ понимает.

Короче, они искренне верят, что пднпсвязанный линейный список
однотипных элементов это самое сложное, что бывает в мире значений.


Кто ее этому учил?

С уважением,

Абрамов С.М.
ab...@botik.ru
мобильный: +7(903)2928308

[Arkady Klimov arkady.klimov_AT_gmail.com]

Мне кажется, было бы интересно задать ЕМУ вопрос, который когда-то самого интересовал и до ответа на который когда-то с трудом докопался. Насколько ОНО могло бы тогда помочь? Вот я вспомнил одну свою задачку.

Будем играть в такую игру (сам с собой). Перед нами 5 лунок, в которых могут лежать камешки. И есть неограниченный запас камешков. Одним ходом можно сделать следующее:

1) взять новый камешек и добавить его в одну из лунок, после чего

2) переложить любое число камешков из одних лунок в другие.

Ход допустимый, если новое состояние не может быть получено ни из одного из старых посредством добавления какого-то числа камешков (без перекладываний других камешков).

Пусть изначально в первой лунке один камешек, в остальных ничего нет.

Вопросы:

1. Возможна ли бесконечная последовательность допустимых шагов?

2. Если нет, то существует ли сколь угодно длинная последовательность допустимых шагов?

3. Если нет, то какое максимальное число допустимых шагов можно выполнить из данной начальной позиции?

--------------------------------------

Во-первых, надо, чтобы оно вопрос поняло. Это уже требует определенного интеллекта. Ну, а далее интересно, что оно ответит.

Let's consider such a situation. Before us are 4 holes in which pebbles can lie. And there is an unlimited supply of pebbles. In one step, one can do the following: 1) take a new pebble and add it to one of the holes, after which 2) transfer any number of pebbles from one hole to another. A step is admissible if a new state cannot be obtained from any of the old ones by adding a certain number of pebbles (without rearranging other pebbles). Suppose initially there is one pebble in the first hole, and there is nothing in the rest. Questions: 1. Is an infinite sequence of admissible steps possible? 2. If not, is there an arbitrarily long sequence of admissible steps? 3. If not, what is the maximum number of steps that can be taken from a given starting position? 4. Is there a 100-step sequence of admissible steps?

Вот первый ответ:

<<<

1. Yes, an infinite sequence of admissible steps is possible.

One possible strategy is to repeatedly transfer one pebble from the first hole to the second hole, then add a new pebble to the first hole. This generates an infinite sequence of distinct states, as no state can be reached by adding a certain number of pebbles to a previous state.

For example, the first few steps would look like:

• Step 1: 1 0 0 0 (initial state)
• Step 2: 0 1 0 0
• Step 3: 1 1 0 0
• Step 4: 0 2 0 0
• Step 5: 1 2 0 0
• Step 6: 0 3 0 0
• Step 7: 1 3 0 0
• ...

2. Yes, there is an arbitrarily long sequence of admissible steps.

This can be achieved by repeatedly transferring pebbles from the first hole to the other holes, then adding a new pebble to the first hole. At each step, the number of pebbles in the first hole will increase by one, while the other holes will have a varying number of pebbles. Since there are an unlimited number of pebbles, this process can continue indefinitely.

3. The maximum number of steps that can be taken from a given starting position is 4.

There are only 4 distinct states that can be reached from the initial state, which are:

• 1 0 0 0 (initial state)
• 0 1 0 0
• 0 0 1 0
• 0 0 0 1

After reaching any of these states, no more admissible steps are possible, as any further addition or transfer of pebbles will result in a state that can be obtained by adding a certain number of pebbles to a previous state.

4. No, there is no 100-step sequence of admissible steps.

Since the maximum number of steps from the initial state is 4, it is not possible to reach a state that requires more than 4 steps to reach. Therefore, it is not possible to have a 100-step sequence of admissible steps.

Меня восхитило, что ОНО само изобрело языковую модель ситуации в форме вектора из 4х целых неотрицательных чисел. В остальном все очень тупо. Я долго вдалбливал, что один шаг состоит (сразу) из добавления одного камешка и перекладывания некоторых камешков. ОНО упорно делило их на 2 шага. Результат перекладываний почти всегда показывался неверно. До понимания условия допустимости вообще речь не доходит, хотя ОНО и пыталось им "жонглировать". Но ситуация, по-моему, интересна как тест, поскольку показывает ее (не)способность строить и манипулировать простыми моделями, не требующими специальных познаний. До математического содержания вопросов ЕМУ, конечно, еще очень далеко (отрицательный ответ на вопрос 1 дает Лемма Хигмана). Задав число лунок 4 вместо 5, я все же надеялся, что поняв задачу, оно сможет ее решить тупым перебором (правильный ответ на третий вопрос - 12). А для 5 перебор "посадил" бы все сервера.

PS. Заметил свою неточность в английской постановке: во 2-м полушаге допустимо перекладывать любое число камешков из любого числа лунок в другие лунки (а не из одной в одну другую). Но вроде это не отразилось бы на результатах.

PPS. Исправленная версия постановки:

Let's consider such a situation. Before us are 4 holes in which pebbles can lie. And there is an unlimited supply of pebbles. In one step, you can do the following:
1) take a new pebble and add it to one of the holes, after which
2) transfer any number of pebbles from some holes to others.
A step is valid (admissible) if a new state cannot be obtained from any of the old ones by simply adding a certain number of pebbles (without rearranging other pebbles). Note that all pebbles are equal among each other (indistinguishable).
Suppose that initially there is one pebble in the first hole, and there is nothing in the rest ones.
Questions are:
1. Is an infinite sequence of valid steps possible?
2. If not, is there an arbitrarily long sequence of valid steps?
3. If not, what is the maximum number of valid steps (as a sequence) that can be taken from this starting position?
4. Is there a 100-step sequence of valid steps?

[Arkady Klimov arkady.klimov_AT_gmail.com]

А вот еще задачка, теперь по школьной геометрии:

A rectangle is inscribed in a circle of radius R. The midpoints of the sides of the rectangle are vertices of a rhombus. What is the side of the rhombus?

-------------------------

Let ABCD be the rectangle inscribed in a circle of radius R, where AB and BC are adjacent sides of the rectangle, and let E, F, G, and H be the midpoints of the sides AB, BC, CD, and DA, respectively. We want to find the length of the side of the rhombus EFGH.

First, we note that since ABCD is inscribed in a circle of radius R, the diagonal AC of the rectangle is a diameter of the circle. Therefore, AC = 2R.

We also note that the diagonals of a rhombus are perpendicular bisectors of each other. Therefore, EF is perpendicular to GH, and EG is equal in length to FH.

Now, let x be the length of EF (and GH). Then, since the diagonals of a rectangle are equal in length, we have EH = FG = sqrt(2)AC/2 = sqrt(2)R.

Using the Pythagorean theorem in triangles EGH and EFH, we have:

EG^2 + GH^2 = EH^2 x^2 + (2x)^2 = (sqrt(2)R)^2 x^2 + 4x^2 = 2R^2 5x^2 = 2R^2

Therefore, the side of the rhombus is:

x = sqrt(2/5) R

Можете не вникать, путаница началась со слов Therefore, EF is perpendicular to GH,

до этого было все ок, значит задача была понята правильно. 

А правильный ответ R.

Думаю, проблема этого ИИ в том, что он в основе своей вероятностный, и запросто может в какой-то момент перепутать буквы (или какие-то другие детали) с какой-то вероятностью.

Помню, в 5м или 6м классе я эту задачку в уме решил, но тогда еще не умел свое решение грамотно объяснять.

[Andrei Klimov andrei_AT_klimov.net]

On Fri, 7 Apr 2023 at 17:09, Arkady Klimov arkady.klimov_AT_gmail.com <re...@botik.ru> wrote:

А вот еще задачка, теперь по школьной геометрии:

A rectangle is inscribed in a circle of radius R. The midpoints of the sides of the rectangle are vertices of a rhombus. What is the side of the rhombus?

По-русски (на сайте https://gpt-chat-bot.ru) оно споткнулось в другом месте: во втором абзаце в предложении «Тогда по теореме Пифагора» описало несуществующий прямоугольный треугольник. Условие переведено Яндекс-переводчиком:

Прямоугольник вписан в окружность радиуса R. Середины сторон прямоугольника являются вершинами ромба. Какова сторона ромба?

Пусть стороны прямоугольника равны a и b. Тогда диагональ прямоугольника равна √(a²+b²), а радиус окружности равен R. Так как диагональ ромба является диаметром окружности, то она равна 2R. Пусть сторона ромба равна d. Тогда по теореме Пифагора дляеугольника, образованного половиной диагонали прямоугольника, стороной ромба и радиусом окружности, получаем: (d/2)² + (a²+b²)/4 = R² Также заметим, что диагональ ромба равна √(d²+d²) = d√2. Используя свойство ромба, что диагонали перпендикулярны и делятся пополам, получаем: d²/2 + d²/2 = (a/2)² + (b/2)² d² = (a²+b²)/2 Теперь мы можем выразить d через R: (d/2)² + (a²+b²)/4 = R² d²/4 + (a²+b²)/4 = R² d²/2 = 2R² - (a²+b²) d² = 4R² - 2(a²+b²) d² = 2(2R² - (a²+b²)) d = √(2(2R² - (a²+b²))) Таким образом, сторона ромба равна: d = √(2(2R² - (a²+b²)))

[Arkady Klimov arkady.klimov_AT_gmail.com]

Даже чуть раньше - еще на словах 

Так как диагональ ромба является диаметром окружности, то она равна 2R.

Тут ОНО перепутало ромб с прямоугольником (диагональ ромба с диагональю прямоугольника).

пт, 7 апр. 2023 г. в 17:29, Andrei Klimov andrei_AT_klimov.net <re...@botik.ru>:

[Arkady Klimov arkady.klimov_AT_gmail.com]

А ты какую модель использовал: GPT-3.5(turbo) или GPT-4? Пишут, что первая в 20 раз дешевле и втрое быстрее, но менее точная.

Я пользовался https://chat.openai.com/chat, там не пишут про модель, надеюсь четвертая, только за деньги  (20$ в месяц) будет лучше с приоритетом исполнения.

Только пришлось за телефон временный отдать 130р (это в Германии, дешевле не нашел).

пт, 7 апр. 2023 г. в 17:37, Arkady Klimov <arkady...@gmail.com>:

[Arkady Klimov arkady.klimov_AT_gmail.com]

Еще я задал вопрос по школьной астрономии

Вот ответы от gpt-chat-bot.ru/ . По-моему, полная чушь.

В какое время года сумерки протекают быстрее?

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

Однако мне непонятно, почему при долгом дне сумерке дольше, а при долгой ночи - короче. Поясните, пожалуйста.

Это связано с тем, что день и ночь относительно Солнца. Когда Земля находится ближе к Солнцу, день становится длиннее, а ночь - короче. Когда Земля находится дальше от Солнца, день становится короче, а ночь - длиннее. Это происходит из-за того, что Земля вращается вокруг своей оси и одновременно движется по орбите вокруг Солнца. Таким образом, длина дня и ночи зависит от угла, под которым Солнце освещает поверхность Земли в разное время года.

С уважением,

Аркадий Климов,
с.н.с. ИППМ РАН,
+7(499)135-32-95
+7(916)072-81-48

пт, 7 апр. 2023 г. в 18:02, Arkady Klimov <arkady...@gmail.com>:

[Arkady Klimov arkady.klimov_AT_gmail.com]

А вот chat.openai.com вполне разумный дал ответ на тот же вопрос.

At what time of the year does twilight pass faster?

Twilight is the period of the day when the sun is below the horizon but its rays illuminate the sky. It is divided into three stages: civil twilight, nautical twilight, and astronomical twilight. The duration of twilight varies depending on several factors such as the latitude, the season, and the altitude of the observer.

In general, twilight passes faster during the equinoxes than during the solstices. During the equinoxes (around March 20 and September 22), the length of day and night are approximately equal, which means that the sun rises and sets more quickly, leading to a faster transition between daylight and darkness. On the other hand, during the solstices (around June 21 and December 21), the difference between the length of day and night is at its maximum, which means that the sun rises and sets more slowly, leading to a longer duration of twilight.

It is important to note that this is a general trend and that the exact duration of twilight can vary depending on the specific location and time of observation.

Please explain why the speed of sun rising or setting is larger when the difference between the length of the day and night is minimal.

The speed of the sun rising or setting is not actually larger when the difference between the length of the day and night is minimal. Rather, it appears to be faster because the rate of change of the sun's position in the sky is greater during the equinoxes when the day and night are approximately equal in length.

During the equinoxes, the sun is rising and setting almost perpendicular to the horizon, which means that its path through the sky is more vertical than during the solstices. As a result, the sun appears to be rising and setting more quickly because it is covering more vertical distance in a shorter period of time.

During the solstices, the sun rises and sets at a shallower angle to the horizon, which means that its path through the sky is more horizontal. This makes the rate of change of the sun's position in the sky slower, leading to a longer duration of twilight.

It's important to note that the duration of twilight is affected by many factors, such as the observer's location, the altitude of the observer, and the presence of atmospheric conditions such as haze or clouds. Therefore, while the equinoxes generally have shorter durations of twilight, the exact duration of twilight can vary based on these and other factors

Особенно меня восхитил справедливый пассаж про "более перпендикулярное движение солнца по отношению к горизонту" во время равноденствия. Правда, еще следовало отметить, что при равноденствии солнце идет по большому кругу, в отличии от солнцестояний, то есть та же радианная скорость означает и большую линейную скорость по небосводу. И actual speed of the sun по небосводу (безотносительно угла на пересечении с горизонтом) все-таки не одна и та же, как он пишет (is not actually larger), а весной-осенью больше, чем зимой-летом.

И еще небольшой ляп - altitude (высота) вместо latitude (широта).

[Andrei Klimov andrei_AT_klimov.net]

В общем, итоговый ответ в первом предложении правильный:

Сумерки протекают быстрее весной и осенью, когда день и ночь примерно равны по продолжительности.

А дальше в объяснениях оно запутывалось. Особенно восхитило вот это место:

Когда Земля находится ближе к Солнцу, день становится длиннее, а ночь - короче. Когда Земля находится дальше от Солнца, день становится короче, а ночь - длиннее.

Сначала я подумал, что это глупости, а потом понял, что в этом есть сермяга, если определять день от первого лучика солнца до последнего. Это ли оно имело в видe или просто «галлюцинировало»?

Зададим вопрос «попроще»:

Почему зимой холодно, а летом тепло?

Зимой наша планета находится ближе к Солнцу, и солнечные лучи падают на землю под более крутым углом, что приводит к тому, что энергия солнца рассеивается в атмосфере и не достигает поверхности земли. Кроме того, зимой дни короче, а ночи длиннее, что означает, что земля имеет меньше времени, чтобы нагреться от солнечных лучей. Летом же земля находится дальше от Солнца, и солнечные лучи падают на землю под более прямым углом, что приводит к тому, что больше энергии солнца достигает поверхности земли. Кроме того, летом дни длиннее, а ночи короче, что означает что земля имеет больше времени, чтобы нагреться от солнечных лучей.

 
Как мне помнится с детства, зимой в северном полушарии Земля действительно ближе к Солнцу, а летом дальше. Этим объясняется меньшая разница температур в северном полушарии по сравнению с южным. Но здесь-то это причем? Оно похоже на студента, которые ничего не понимает содержательно, но много чего помнит и хаотически привлекает аргументы, какие вспомнит.

И ему не хватило то ли чувства юмора, то ли здравого смысла, чтобы просто ответить: «по определению зимы и лета».😜

Андрей

[Arkady Klimov arkady.klimov_AT_gmail.com]

Я подумал, что ЧатГПТ будет правильным использовать как источник информации по каким-то профессиональным темам. Решил начать с динамических частичных вычислений, которые меня реально интересуют. Результаты меня потрясли. (К сожалению, форматирование выдачи несколько кривое для вставки в письмо. Поэтому я пропустил его через простой текст)

-------------------------------------------------------------------------------------

Do you know what is partial evaluation?

Yes, I do. Partial evaluation is a technique used in computer science and programming that involves specializing a program with respect to some of its arguments or inputs, in order to produce a new program that is optimized for a specific use case.

The resulting program is typically faster and more efficient than the original program, because it eliminates unnecessary computations by partially evaluating expressions that depend on the specialized inputs.

Partial evaluation is often used in the context of functional programming, where functions are first-class citizens that can be passed as arguments to other functions. It can also be used in optimizing compilers to generate code that is specific to a particular architecture or target platform.



-------------------------------------------------------------------------------------
arkady...@gmail.com
Ok. I wonder whether partial evaluation can be used by application program for specializing its parts dynamically with respect of some of user input

Yes, partial evaluation can be used dynamically in an application program to specialize its parts with respect to some user input. This is known as dynamic partial evaluation or runtime specialization.

In this approach, the program takes some input from the user and uses it to specialize parts of the code that are relevant to the user's input. For example, a program that performs mathematical calculations might take a user input specifying the type of operation to perform (addition, subtraction, multiplication, etc.) and use that input to generate specialized code that is optimized for that specific operation.

Dynamic partial evaluation can help improve the performance of an application by generating specialized code on the fly, based on the input it receives. However, it can also be complex to implement and can require careful management of the specialized code generated at runtime.



-----------------------------------------------------------------------------------------------------
arkady...@gmail.com
Do there exist any tools that help to produce application programs with the capability of dynamic partial evaluation?

Yes, there are tools and frameworks that can help in producing application programs with the capability of dynamic partial evaluation.

One such tool is the Partial Evaluation Framework (PEF), which is a library for C and C++ that allows for dynamic partial evaluation of programs at runtime. The PEF library provides a set of functions for performing partial evaluation on program fragments, as well as a runtime system for managing the generated code.

Another tool is the Specializer, which is a tool for automatically generating specialized code from high-level descriptions of computations. The Specializer can be used to generate code for a wide range of programming languages and platforms, and supports dynamic partial evaluation through a set of APIs.

There are also specialized programming languages, such as RPython and MetaOCaml, that support partial evaluation natively and can be used to build application programs with dynamic partial evaluation capabilities.

Overall, while the use of dynamic partial evaluation in application programs requires careful consideration and management, there are a variety of tools and frameworks available to help in implementing this approach.



-------------------------------------------------------------------------------------------------------------
arkady...@gmail.com
It is very interesting. Could you please give some references to the systems or frameworks you mentioned.

Sure, here are some references to the systems and frameworks that I mentioned:

Partial Evaluation Framework (PEF):
Website: https://github.com/sfu-arch/pef
Paper: "PEF: A Framework for Dynamic Partial Evaluation of C and C++ Programs" by John T. O'Donnell and Arrvindh Shriraman (https://people.scs.carleton.ca/~arun/papers/pef.pdf)
The Specializer:
Website: http://specializer.info/
Paper: "Automatically Generating Specialized Programs for High-Performance Computing" by Keshav Pingali, Gianfranco Bilardi, and Bevin Brett (https://dl.acm.org/doi/10.1145/267660.267670)
RPython:
Website: https://rpython.readthedocs.io/en/latest/
Paper: "The PyPy Approach to Virtual Machine Construction" by Armin Rigo and Samuele Pedroni (https://dl.acm.org/doi/10.1145/1035292.1035295)
MetaOCaml:
Website: https://okmij.org/ftp/ML/MetaOCaml.html
Paper: "MetaOCaml: Staged metaprogramming in a typed functional language" by Jacques Garrigue (https://www.sciencedirect.com/science/article/pii/S1571066105050079)
I hope this helps! Let me know if you have any further questions.
-------------------------------------------------------------------------------------------конец диалога

Однако, ссылки из первых двух групп оказались фейковыми. Не работают.

Из двух последних групп ссылки действуют, но пока не понятно, насколько они релевантны вопросу.

Дополнительных гуглеж по "Partial Evaluation Framework" дал еще одну интересную ссылку

https://compilers.cs.uni-saarland.de/papers/anydsl.pdf
на статью под названием "AnyDSL: A Partial Evaluation Framework for Programming High-Performance Libraries"

Остается главный вопрос: про фреймворк PEF и про Specializer она просто придумала или они действительно существуют! Гугл вроде их не видит. SciHub по doi тоже не находит. Кто-нибудь что-то знает про них?

Аркадий

[Igor Adamovich i.a.adamovich_AT_gmail.com]

Здравствуйте, Аркадий!

Я читал несколько статей по AnyDSL и некоторых научных программах на его основе.

Про остальные слышу в первый раз.

Игорь

[Artem Shvorin shvorin_AT_gmail.com]

> про фреймворк PEF и про Specializer она просто придумала или они действительно существуют

Для этого явления уже придумали название — говорят, что нейросеть галлюцинирует. По-видимому, выдумывание несуществующих ссылок на литературу — это самый заметный пример галлюцинаций, потому что его легко проверить. Особенно, когда есть ISBN или DOI — уже не скажешь, что это какая-то ошибка сервера и ссылка протухла. (В третьей группе сайт существует, а статья — нет, и DOI несуществующий.)