Журнал изменений flang

Релиз языка — это тег vX.Y.Z, а по нему архив формулы и публикация в npm. Строки под релизом — заголовки коммитов, вошедших в него: в этом репозитории заголовок пишется утверждением о том, что теперь правда, поэтому он и есть готовая запись журнала. Правки, от которых язык снаружи не меняется, — планы, спецификации, тесты, скрипты, — сосчитаны, но не перечислены.

Не выпущено

• chore(release): the tap serves flang-package, the checks follow it (7936da8)

0.7.29 — 18 октября 2026

Готовые сборки и установка одной командой, законы категорий доказываются

• chore(release): sha256 of the 0.7.29 archive and the full notes (2a71e57)
• chore(release): version 0.7.29 and its release notes (2b7b6c5)
• test(probes): run on a refused record field answers code 1, not 3 (992a621)
• fix(checker): the second checker keeps the reader of dev for its laws (6fa568a)
• chore(seed): reseed the shell over dev and take the fingerprint (117fb38)
• chore(seed): print batch eight (0f531a8)
• docs(adr): adr-0121 makes a declared law a statement of the kernel (e5f2c07)
• fix(ct): the bifunctor court keys a pair of names on one line (f9507c6)
• feat(ct): a declared law is a statement the kernel judges for all values (6382b99)
• fix(ct): nine programs declare the translations and equalities they lack (de94145)
• fix(cli): check --proof asks the checked program what was not counted (99ade27)
• feat(checker): checkers derive the declared laws past the source end (a1203f8)
• chore(guards): ledgers and prose numbers follow the new probe files (d69a3df)
• feat(record): proved statements carry moves read off the function body (0ccdf7a)
• fix(record): the move-form derivation reaches the reader (c0b95cd)
• fix(checker): the fields move and an unfold of a whole call only (b091f87)
• fix(parser): a nested object line is refused as an old word (f56349b)
• fix(test): the compiler imports the scheduler after its own lists (ac45af6)
• feat(test): run blocks are executed and their expectations checked (62d501d)
• fix(bounded): the step estimate counts the postcondition check (429a7a7)
• refactor(conc): scheduler names no longer clash with the compiler (1364adc)
• fix(link): a name outside an only list is refused in any import order (71729dc)
• fix(run): consent to the unproven no longer runs an unlinked program (47f7160)
• fix(link): an exported function may call a helper its module hides (704a05f)
• fix(emit-c): the printed makefile names the tls client of the shell (d37931b)
• feat(self): make install lays down share/flang (8733178)
• feat(checker): both checkers replay exploration records (0d48131)
• feat(temporal): explore always-properties of a finite process model (f376a6e)
• feat(translation): validate the printed C against the reference (e02b026)
• feat(lean): reference answers on witnesses for translation validation (e5db23a)
• chore(seed): reseed the shell after statements and syllogisms (e11d342)
• test(repl): probes for statements and syllogisms fed on stdin (6e483b5)
• fix(repl): judge statements and syllogisms in the shell (fc4978f)
• chore(proof): ratchets follow the new forgeries and probes (ae470e5)
• docs(adr): 0160 the checker reads what the kernel proves (68b859f)
• fix(checker): a match after a multi-line example still opens the body (8cec902)
• fix(checker): count postconditions in code, not in text blocks (7578563)
• fix(checker): monad blocks call their unit and join, quotes in names (a7d40f8)
• fix(checker): examples by value, joined restrictions, more readers (cff9908)
• fix(checker): a claim's place is its line, names keep their and (189bbea)
• fix(checker): read calls in code, sums over a segment, true counts (7cc2eed)
• feat(checker): read foreign surfaces, compare numbers as the language (75c9fa0)
• fix(checker): a case is read only from the body's own match (74decc8)
• chore(seed): reseed the shell after the verdict change (7399e70)
• fix(guards): falsifier and word guard follow the code contract (063d65b)
• chore(proof): register the forgery programs and refresh the counts (a24e075)
• test(proof): the strict probe names its import helper apart (a66c325)
• fix(cli): the shell speaks plain words in seven more messages (c49a29e)
• fix(proof): grid and checker disagreement give code 3, not 0 (23f6135)
• fix(proof): the exit code of check --proof says what was proved (c3ef7f0)
• test(unicode): official conformance tests and a ten target probe (ff0e134)
• feat(stdlib): explicit decoding of bytes with an honest refusal (f75a8ca)
• feat(stdlib): normalization, grapheme clusters and case folding (6b7424d)
• feat(stdlib): unicode 17.0.0 tables generated from the UCD files (90e31cb)
• build(seed): reseed the runtime mirror after rebase (a88b960)
• build(seed): take the runtime mirror of dev before reseeding (6882b72)
• feat(site): a playground checks flang and syllogisms in the tab (0b0d423)
• chore(seed): reseed the shell and the runtime for wasm32-wasi (d2fb4da)
• fix(emit-c): the shell and the runtime build for wasm32-wasi (e0130e7)
• feat(proof): the reference semantics is compared with the binary (48b7728)
• feat(lean): a reference semantics of the language core with theorems (1340d78)
• feat(lean): the model rounds integers in binary64 (43591bd)
• chore(seed): refresh the copied runtime with carried memo pins (3415002)
• perf(runtime): memo pins follow moved values, inline field read (4a87587)
• docs(ct): the resolver module and the corpus plan get distinct names (d435bae)
• docs(ct): specify proofs about every category, with a Lean corpus (8c138b7)
• docs(adr): 0145 unfolding takes the arguments and names what Lean misses (c667fa8)
• fix(checker): unfolding refuses a parameter the substitution misses (924070c)
• fix(checker): the compute move reads string literals in escaped form (4b33bb0)
• fix(checker): unfolding puts the call arguments in place of parameters (c5b70f9)
• chore(asdf): the plugin submodule counts only target directories (ff9468e)
• fix(packaging): the parity probe of the library fits the lint limits (de827a9)
• feat(release): ship the standard library with every install (c501f7b)
• feat(proof): measure the prover against lean on forty tasks (1b8f9fe)
• docs(adr): 0127 lifts the checker ceiling by the half moves (02e1b60)
• fix(checker): evaluator no longer computes element and symbol (fdc2af8)
• feat(lean): rules guard counts the half moves (20fdcae)
• feat(lean): every half move of the checker has a soundness theorem (6e8deff)
• fix(checker): half moves keep facts out of pattern scopes (cb36663)
• chore(asdf): the plugin submodule points at the prebuilt-first plugin (24e0c06)
• fix(asdf): the c archive fallback builds with the makefile flags (e52119d)
• fix(packaging): the parity instrument runs on an installed flang (700a851)
• feat(packaging): the parity instrument compares any number of installs (68de7ad)
• feat(asdf): the plugin installs the prebuilt build and falls back to C (38ba44e)
• build(packaging): homebrew and aur manifests for flang-package (033a1f3)
• ci(release): four prebuilt tarballs, deb, rpm and one sha256sums (b02a1cc)
• test(probes): 71 russian sentences are judged by the pregroup parser (208d78f)
• feat(ct): a russian sentence is checked by a pregroup of typed words (91192ab)

Ещё 141 правка языка снаружи не меняют.

0.7.28 — 14 октября 2026

Примеры в законах проверяются, ошибки в категориях находятся при компиляции

• chore(release): point the Homebrew tap at 0.7.28 (4cf15a3)
• chore(release): the Homebrew formula knows the 0.7.28 archive hash (48ca7c3)
• chore(release): version 0.7.28 and its release notes (b4e30f7)
• test(ct): the law probe set checks exit codes of the batch seven rows (85a591d)
• chore(seed): print batch seven (0ddadb9)
• test(ct): probe set ct-laws asks for law examples and shape rules (c4c0a4a)
• feat(ct): law examples run and the shape of categories is judged (2e0f9f3)
• fix(tables): eleven kernel anchors follow the rewrite limit lines (37967bb)
• feat(kernel): the ledger names the rewrite limit when rewriting runs out (44654ae)
• perf(kernel): rewrite rules come only from functions the goal calls (55657f7)
• feat(proof): both checkers replay a quantifier under a connective (29fc4a7)

Ещё 18 правок языка снаружи не меняют.

0.7.27 — 14 октября 2026

Печать партий 5 и 6: кольцо точного целого у двух сличителей, мера и постусловия в ядре, TLS вшит в двоичный, формулы с кванторами и LaTeX

• chore(release): point the Homebrew tap at 0.7.27 (a59116a)
• chore(release): the Homebrew formula knows the 0.7.27 archive hash (02ed834)
• chore(release): version 0.7.27 and its release notes (36ad758)
• fix(probe): build the tree shell beside the seed runtime header (dba067b)
• test(probes): the batch six binary meets the probes it was printed for (c85424b)
• chore(seed): print batch six with the record lines broken (181ba1f)
• style(compiler): long record lines break inside parentheses (970a79d)
• chore(marks): the marks and visible counts follow batch six (e8d189e)
• fix(proof): the checker ceiling counts adr-0092 and adr-0105 (81eeb09)
• test(probes): name the strict program in English words only (29fce08)
• test(probes): strict and ct-laws ask the ledger for the judged grids (bad36f3)
• feat(ledger): the judges hand their grids to the ledger (de7d11c)
• refactor(emit): plan printing fits the line and nesting limits (42b29f1)
• feat(emit): a plan prints into c, go, rust and python (fafad7b)
• test(probes): network probe set with forged certificates (a57fe8c)
• feat(io): https by the printed language tls client, udp datagrams (9f6d89c)
• style(probe): probe lines stay under 120 characters (4d46f9a)
• fix(emit): the host hands the entry table to every target (89cdacc)
• feat(types): declared types hold at the runner of every target (774f1fb)
• refactor(proof): the literal order joins the strict branch by a choice (a89f122)
• chore(proof): kernel lines fit the lint limit and the ledgers follow (a3c3233)
• feat(proof): the kernel reads the branch condition and compares literals (891d5aa)
• chore(ledgers): the inventory and file-name words know the wrapped goals (c75acd9)
• test(checker): a wrapped postcondition and goal with a kernel record (2fe1287)
• test(checker): the chain of eighteen wraps its goal over five lines (59f7429)
• refactor(lexer): the bracket step after a sign is its own function (c688cd5)
• test(proof): a probe of line continuation inside parentheses (44c4995)
• feat(checker): both checkers read a goal across lines to its close (62fad86)
• feat(lexer): a line with an open parenthesis continues to its close (ca2700a)
• test(proof): the probe of seventy calls waits for the printed word (b0159e3)
• feat(checker): the second checker replays a rewrite by a postcondition (018d5f5)
• test(proof): probe programs carry their subject text and name themselves (3d42071)
• refactor(kernel): the postcondition rule keeps its function in the key (bda2781)
• test(proof): the record of the eighteen-call chain replays under Perep2 (e9171d7)
• test(proof): probes and checker family for rewriting by a postcondition (eb30680)
• feat(kernel): a proved equality postcondition rewrites its call (Perep2) (bc33bbf)
• test(probes): the measure probe programs carry ledger words (2ef5ae9)
• docs(adr): adr-0093 names the descent term and the final runs (0fe217f)
• refactor(kernel): the measure rules read a descent term within the lint (b291149)
• fix(lean): the mer ban lemma carries the ban name the ledger reads (7fd0e02)
• test(probes): the measure probe names the rebased runs and the seed (642bbc4)
• test(checker): a forged declared-measure descent is refused (f1aaa0a)
• test(probes): declared-measure-descent holds the four measure forms (b9a69e2)
• feat(kernel): the declared measure is proved by its descent or refused (74e450f)
• feat(checker): the second checker replays the exact integer ring (3c2e5d2)
• fix(proof): the checker ceiling counts adr-0103 from dev (1ac46f4)
• test(probes): strict and ct-laws follow the seed of batch five (5f3f1cc)
• chore(seed): reprint the seed from print batch five (bdb5f9d)
• fix(lean): the ring lemmas of adr 0095 build under lean 4.34 (b0a3e82)
• docs(adr): 0097 the checker ceiling follows its rules, guard in ci (cd5e2e3)
• chore(rules): anchors and counts follow the merged kernel (9eb2292)
• chore(rules): the ledger digest follows the merged rule rows (e2668d3)
• fix(kernel): the monomial joins are total, as their caller requires (5d9a72d)
• chore(ledger): anchors follow the split ring line, ring rows counted (8a730f4)
• refactor(kernel): keep the ring lines under the width limit (5a30ce7)
• test(probes): ring probe proves eight laws and refuses with a cause (1877571)
• docs(rules): ledger rows and lean lemmas for the exact ring family (eb4ca47)
• feat(checker): replay the exact ring rule by expanding both sides (c44c18b)
• feat(kernel): ring laws over the exact integer as one polynomial rule (e7e8821)
• feat(proof): refuse a wrong named witness, probe quantifiers in formulas (bfc3292)
• refactor(rules): the segment sum rule is Kol5; Kol2-Kol4 are the ring (05a93c1)
• feat(kernel): a literal sum over the nonnegative segment closes by Kol2 (3c654dc)
• fix(ct): the courts share types and defer to the kernel monoid court (0da8ba9)
• test(ct): probe set ct-laws tells the law court from silence (78704a8)
• fix(ct): court helpers no longer shadow parser and ledger names (a145818)
• feat(ct): the binary judges every declared law of the category surface (d23c71f)
• fix(messages): the language code and home path fit their buffers (b2b7e3c)
• fix(messages): the language origin fits its buffer under lto (75017a5)
• build(seed): the seed shell learns the message catalog (83ece60)
• fix(probes): the language probe writes its .flangrc into a temp dir (34a7a9b)
• fix(messages): the catalog guard and the probe pass the tree guards (e9c2560)
• feat(messages): flang check answers in the language of the settings (d3d032e)
• feat(translation): the matcher replays the measure guard by its shape (1c0fec0)
• feat(checker): both checkers replay restricted citations and hypotheses (d9ed9d8)
• feat(checker): the second checker reads the record format of 11 october (cd7e677)
• feat(checker): the forged copy goes to both checkers, both refuse (93cd43c)
• fix(lean): not-a-number equals itself in the model, as in the language (3b8c95a)
• chore(seed): reprint the seed from the batch after the import fix (1395fd1)
• test(probes): the two step modules carry English file names (14a95c8)
• test(probes): import-helper-binding holds the issue 349 and 350 programs (61ad7f6)
• fix(link): an imported helper binds in its own module or link refuses (7f80382)
• feat(ct): monoidal routes, maybe as monoid, kleisli arrows (8c21827)
• test(ct): two adjunctions and yoneda are judged on the grid (fe6a850)
• test(ct): product, coproduct and pullback are declared cones in flang/ct (683ad13)

Ещё 129 правок языка снаружи не меняют.

0.7.26 — 11 октября 2026

• chore(release): point the Homebrew tap at 0.7.26 (83e848c)
• chore(release): the Homebrew formula knows the 0.7.26 archive hash (530b5c5)
• chore(release): version 0.7.26 and its release notes (80f0d86)
• test(probes): the strict probe keeps an unjudged surface (a18d45a)
• chore(marks): the numbers follow the batch after the rebase (721110a)
• chore(seed): reprint the seed by its own printer (print 2) (4dfbb7f)
• chore(targets): the canons ledger follows the seed of this batch (70c078d)
• test(proof): the new seed closes the pattern-shadow hole (cec9fc5)
• chore(seed): reprint the seed from the batch after 0.7.26 (ee49268)
• style(emit): the chunked map lock in C# follows dotnet format too (d728f86)
• chore(ledgers): rule anchors and share rows follow the merged batch (3dc92d9)
• feat(self): lay out printed C and C++ the way clang-format LLVM does (39d82d0)
• feat(self): print C# arrays and lists as collection expressions (ede306a)
• style(emit): lay out the C and C++ runtimes with clang-format LLVM (1d78d95)
• style(emit): the C# runtime follows dotnet format at severity info (56ca595)
• test(bench): a gate for the parallel map and the monoid fold (1aa9613)
• feat(emit): map and fold in chunks in Go, Java, C# and Elixir too (13058c3)
• feat(check): the kernel judges monoid laws and marks the folds they cut (0692c99)
• feat(kernel): the exact ring drops a written empty list from a sum (e63dfdb)
• feat(emit): print a total map and a monoid fold in chunks in C (7c21739)
• feat(runtime): the C runtime maps and folds a list in chunks on a pool (65864e7)
• docs(adr): 0084 adds Perep1, Skl1-Skl3 and Sv2 with their ledger rows (ebbc1a9)
• test(checker): rewriting, found witness and inner quantifier probes (17227d3)
• fix(self): rewriting helpers defined once and named apart (a2e3f40)
• feat(lean): measure of the concat laws, Sv2 and the IEEE counterexample (fb7553c)
• feat(checker): kinds of a rewrite rule and a witness found by the kernel (77cdc70)
• feat(self): rewrite by proved equality, inner and found witness (9f62c53)
• chore(ledgers): pattern-shadow probes get English names and share rows (5b17b48)
• test(proof): register the pattern-shadow hole with probes and a template (b2ee866)
• fix(kernel): a pattern name that shadows a parameter refuses induction (fe25a76)
• test(probes): greeting is replayed by the checker and the counts follow (2be9246)
• fix(checker): no length laws and reductions keep their place (a17fb37)
• test(checker): probes for case splits that use facts (8c4860e)
• feat(checker): evaluator knows or, not, element and character (5b9783c)
• feat(checker): lengths are counted and split facts follow the half (b54dc02)
• feat(checker): requires and replayed callee promises as facts (dd9dcd8)
• feat(checker): a half that does not close unfolds calls once (a9d533c)
• feat(checker): algebra node cases read like the goal split (309a7c0)
• fix(checker): substitution skips field names and string literals (1712db3)
• feat(checker): case split over match bodies and quoted strings (348e482)
• feat(checker): case split reads more bodies and links atoms (425b8a1)
• chore(licenses): drop SPDX header lines from source files (1149c78)
• build(seed): reseed the runtime mirror for the plain check messages (ee54041)
• fix(cli): check messages name the proof report in plain words (3190d01)
• fix(checker): the literal law reads a zero in parentheses (9f01819)
• chore(proof): forgery-probes ratchet follows the verdict (5da1af5)
• fix(checker): close the gaps the second checker found (d9a8856)
• feat(checker): the second checker gives a verdict on every record (b99af39)
• build(seed): reseed the runtime mirror after rebase (6df4059)
• refactor(registry): the lock fix and the registry job carry no comments (d9d6304)
• fix(lock): every form of a dependency reaches the lock file (1f2f8ea)
• feat(guards): registry resolution is proved by a corpus and a forgery (52f86a2)
• build(seed): reseed the runtime mirror after rebase (ce2d4d1)
• refactor(repl): the plan judge call and its CI job carry no comments (fe5c300)
• fix(repl): check asks the plan judge and twelve forgeries fail (c12bcbb)
• build(seed): reseed the runtime mirror for the cost report (3585b88)
• feat(run): flang run --cost and the runner's cost field report the price (9a807e1)
• test(probes): keep the conditional syllogism premise unproved (7ca01eb)
• chore(seed): reprint the seed by its own printer (print 2) (2c25eea)
• fix(emit): printed JS arithmetic returns any to the TypeScript checker (dcb7e17)
• test(probes): the integer part of a fraction agrees in ten targets (aaf81b2)
• chore(proof): ratchets follow the verdict on the 0.7.26 seed (1b0632c)
• chore(seed): reprint the seed from the 0.7.26 batch (a8e8b4d)
• docs(tls): an HTTPS GET plan, RFC 8448 vectors, forgeries and ADR-0078 (3581164)
• feat(stdlib): a TLS 1.3 client and a certificate path check (42666cd)
• feat(stdlib): verify RSA-PSS and fix the modulus remainder in rsa (5951f9c)
• feat(host): hand out random octets from the system source (5088b62)
• perf(runtime): only the watching thread writes names on the call path (d4f7978)
• feat(proof): cache kernel answers across runs in a signed directory (c4fbf7b)
• feat(emit): lay printed code out the way each target's formatter does (70c2159)
• fix(emit): escape characters the targets refuse in string literals (9a8b2da)
• test(probes): exact actions agree between the evaluator and ten targets (f78b3af)
• feat(self): the integer part of an exact fraction is a built-in form (fef758f)
• feat(emit): every target runtime computes exact integers and fractions (dd8d86a)
• chore(ledger): test names in English words, counts follow the tree (4fe633b)
• docs(adr): 0075 adds Ind5, Ind6 and Cel3 with their ledger rows (52e2c8f)
• test(checker): three families for segment-form, Cel3 and enumeration (50c6220)
• feat(lean): lemmas and traps for Ind5, Ind6 and Cel3, Cel3 accepted (8dfe55a)
• feat(checker): replay segment-form principles and the Cel3 move (956398e)
• feat(self): segment induction, integer tightening and enumeration (b71f1f7)
• feat(probes): a user story is written in nine fixed sentence forms (00ec96a)
• test(falsifier): keep only the findings trunk still has (ca79e11)
• refactor(falsifier): rewrite the probe sources to pass flang lint (2bd5797)
• style(falsifier): wrap the probe sources where the grammar allows (0dd2575)
• test(falsifier): count the checker refusing theorem-only hypotheses (fad0c0a)
• docs(proof): name the parenthesised shape of the open-term record (09c4dcc)
• docs(proof): register what the falsifier found (3b9c66e)
• test(proof): search for false proofs with a falsifier probe (5110733)
• chore(proof): ratchets and the default row after the kernel-trust merge (c2bd85b)
• fix(checker): the second checker file is named in English words (81964a1)
• feat(checker): a second record checker in Lean, crosschecked with C (437e4e1)
• test(share): the empty-record probes expect the checker to refuse (54f3edb)
• fix(checker): a record with nothing proved answers 3, not 0 (b4943a1)
• fix(proof): every kernel rule has a table row, and the guard says so (4fbbe70)
• feat(lean): the last five checker moves enter the acceptance (05ac67c)
• build(seed): reseed the runtime mirror after rebase (47626c5)
• feat(cli): check --proof says how much the checker replayed (c797018)
• feat(proof): count proved statements the checker replays, set by set (f7d0fba)
• feat(checker): replay conditional bodies the kernel closes by case split (7f357fe)
• feat(bench): pool scaling bench is a plan, ADR-0072 on parallelism (07407b8)

Ещё 112 правок языка снаружи не меняют.

0.7.25 — 6 октября 2026

• chore(release): point the Homebrew tap at 0.7.25 (6286aaf)
• chore(release): the Homebrew formula knows the 0.7.25 archive hash (84da550)
• chore(release): version 0.7.25 and its release notes (40d3025)
• fix(proof): the new forgery is named and the zettel link resolves (fa1b622)
• fix(checker): a case split refuses its condition under a binder (25b95f1)
• feat(lean): moves n6 and o9 enter the acceptance with their theorems (703f16b)
• feat(proof): a guard counts checker moves against the lean acceptance (9dfecf5)
• fix(ci): the ten-target probe waits for dotnet and names a missing tsc (d0961a1)
• chore(seed): reprint the seed after the line-length pass (print 5) (cba8740)
• chore(ledger): marks and share rows follow the shortened lines (ca28a90)
• style(guards): the last ten long lines of the batch are under 120 chars (fe1e81b)
• style(bench): the two ADR-0061 plans keep lines under 120 chars (3fa1ed6)
• style(self): the batch keeps every added line under 120 characters (c07c532)
• test(probes): the generator probe is named in English words (176d800)
• chore(ledger): the proved-share rows count the fraction promises (ff1b3c4)
• test(probes): the exact-integer division refusal names the remainder (b1a8e9c)
• chore(seed): reprint the seed with the exact fraction (print 4) (0c46d19)
• fix(self): the order over two exact fractions passes the typechecker (cf27824)
• test(probes): thirteen programs ask the exact fraction before the print (e1875be)
• feat(self): the exact fraction is a reduced pair of exact integers (f9a3de0)
• docs(adr): the process-limit decision takes number 0061, 0056 is on dev (a98f29e)
• chore(seed): reprint the seed from the eight-work batch (e15289d)
• fix(self): the three canon gate functions are total, as the rest are (09ae551)
• test(probes): the exact integer probe holds canon, not only addition (b2cf681)
• feat(self): the exact integer subtracts, multiplies and compares (31b696a)
• feat(rules): prove addition associativity over the exact integer (e965185)
• fix(bench): the plans keep temporaries out of the tree and out of bash (9de4797)
• feat(bench): the memory limit and the node death benches become plans (c2fb3ce)
• feat(self): a spawn order names a memory and a time limit for its child (b8679ac)
• test(probes): every print target builds and sums beyond two to the 53rd (c761e84)
• feat(emit): the exact integer adds digits in every target runtime (9a82af6)
• fix(emit-c): the printed Makefile names each object's headers (1cd19e1)
• chore(ledgers): three recounts and four prose numbers follow 1908 (4b8f7bf)
• test(probes): the exact integer probe holds the type, not its absence (8e80c2d)
• feat(self): the exact integer is a type of its own beside the integer (f5b8e40)
• refactor(experimental): morphology leaves the standard library (ace2257)
• feat(stdlib): russian morphology answers a dictionary entry or a gap (7206756)
• build(seed): reseed for the LSP read fix and stamp the print inputs (d26780e)
• fix(lsp): answer while stdin is open and decode \uXXXX in JSON (d5a0ea4)
• build(seed): reprint the seed for the LSP read fix (5f0ae6a)
• fix(lsp): answer while stdin is open and decode \uXXXX in JSON (d6e9733)
• refactor(translation): the matcher suite is a proved plan with 32 probes (34db94f)
• test(probes): sixty-two reasoning texts cover all twenty-four moods (8ccbb18)
• fix(repl): the refusal names imported modules instead of denying a cause (843c429)
• test(probes): the plan judge is asked on fourteen samples (6e37480)
• test(probes): the two tables say they are a defect, not a contract (075aeb2)
• test(probes): run verdict surfaces and import order get probes (76b68dd)
• fix(ledger): all 112 rule anchors point at real kernel lines again (efdab64)
• fix(translation): filter is replayed and the measure guard is counted (45c8c04)

Ещё 116 правок языка снаружи не меняют.

0.7.24 — 3 октября 2026

• chore(release): point the Homebrew tap at 0.7.24 (1eaf6a5)
• chore(release): the Homebrew formula knows the 0.7.24 archive hash (73bbd80)
• chore(release): version 0.7.24 and its release notes (c7226d3)
• build(seed): reprint the seed after the reflow (4dbdc2d)
• fix(lexer): the new complaint helper gets a name of its own (7dcfccf)
• style(self): reflow the lines the 0.7.24 gate flagged (a1b84be)
• chore(ledgers): the ceilings and the inventory follow the new seed (591797e)
• fix(proof): three soundness violations are closed by the new seed (b95064d)
• build(seed): reprint the seed for 0.7.24 (15a64f6)
• fix(probes): the checker finds no record when the kernel refuses (8c67fb3)
• refactor(self): english file names and no comments in compiler sources (10f5143)
• test(probes): keep restricted postcondition citations as probes (c02cc83)
• fix(kernel): cite a restricted postcondition only when discharged (5ce622f)
• fix(totality): see calls made through function values (9afb9db)
• fix(kernel): refuse a theorem whose hypotheses the statement lacks (4f5af41)
• feat(lexer): text block literal """ strips its common indentation (b5c4039)
• feat(emit-c): print memo wrappers around three kernel functions (e14e374)
• test(probes): measure that the exact integer is absent (d36dadb)
• fix(tutor): pick a locale and an awk that keep UTF-8 whole (e8f7187)
• refactor(names): the lesson extension of the tutor becomes english (60d9e41)
• refactor(names): 14 cyrillic names and 4 fixture dirs become english (8f964e7)
• fix(checker): a property step over a free statement is replayed (9dea6fd)
• fix(test): name the scenario blocks nothing ran and exit 3 (2937671)
• fix(stdlib): date from days holds below year one (eaaf74e)
• fix(tutor): the word list of the tutor catches up with the lexer (d746cdc)
• feat(checker): a strict key tells an empty ledger from a proof (319c980)
• fix(tutor): the lesson value is read from stdout alone (c94e49c)
• fix(checker): an identity over an open term is replayed, not a lie (cec6de5)
• build(seed): copy the lint runtime after the rebase onto profiles (aee445b)
• style: wrap long lines in comment-free sources under 120 characters (6eb196b)
• feat(cli): add flang lint for line length and conditional depth (12310e3)
• test(probes): expect the checker to refuse the theorem-only hypothesis (a91b02e)
• chore(numbers): raise checker ratchets after the rebase onto fmath (66b6d82)
• fix(checker): keep the theorem line apart from the step kinds (28b5c54)
• fix(checker): name two assumption-replay probes in listed words (c8ad687)
• feat(checker): replay by-assumption steps from the statement premises (03b89c4)
• fix(checker): name the forged precondition probe in listed words (c7363af)
• fix(checker): reject a record whose hypothesis is not the statement's (782f757)
• build(seed): reseed the runtime mirror after rebase (52eda8d)
• build(seed): take the runtime mirror of dev before reseeding (090bf01)
• feat(cli): select library modules by a profile in .flangrc (1257242)
• feat(stdlib): add long division, gcd and exact rationals (32e8610)
• chore(numbers): sync counts and raise the probe ratchet to 611 (dd241b6)
• feat(stdlib): first proved statements of fmath, cited across files (0e93aa1)
• chore(numbers): sync counts and raise the probe ratchet to 608 (e63ce93)
• fix(checker): replay property steps, cite across files, project fields (a09e8a5)
• chore(numbers): sync counts after rebase and raise the probe ratchet (c807e41)
• fix(checker): read module types and dependency sets as the linker does (8b5e1d0)
• fix(checker): replay what the kernel proves in user programs (80e8707)
• refactor(proof): run the record forgeries from a table and a plan (3a6bcb4)
• refactor(proof): measure the corpus share and self-test it from plans (3b8810c)
• refactor(proof): measure the share by replay from a plan (38834a4)
• docs: name the three open soundness holes (eb61db4)
• fix(ci): give the proof probe steps a temporary directory (9da3488)
• refactor(proof): check corpus nesting and the ledger probe from plans (39eb750)
• refactor(proof): judge the files named by records from a plan (b8b7245)
• refactor(proof): write and probe the seed fingerprint from a plan (21e447c)
• refactor(proof): guard the inference-rule tables from a plan (b35ad88)
• refactor(proof): cross-check the rules with Lean from a plan (d6dc1b5)
• refactor(proof): match the rule lists from a plan (60ee8b8)
• refactor(proof): call the checker and the small reducer from plans (f878def)
• refactor(proof): run the checker probes from a table and a plan (8531676)
• refactor(proof): turn the part-count forgery script into a plan (069fffc)
• refactor(proof): turn the lie verdict script into a plan (d3fd7d2)
• chore(seed): refresh the copied runtime with the call memo (f20c50d)
• feat(runtime): remember pure kernel calls within one run (0b69f17)
• chore(numbers): sync measured counts after the cleanup (ef2f09d)
• refactor: drop Python instruments, the per-file share becomes a plan (4311724)
• refactor(proof): keep the proof tables as data, prose goes to docs (e5cb78f)
• chore(ledgers): strip comment prose from data files (373ff04)
• docs: keep prose out of flang/ and bootstrap/ (5318da1)
• refactor(proof): keep forgery manifest and ratchets as plain data (cbca30e)
• chore(sources): strip comments outside the print inputs (e490d64)
• feat(settings): keep short commands in the settings file (d1e70c4)
• feat(cli): run short commands from the settings file (dffe611)
• feat(proof): reasoning in sentences, premises as assumptions (96cb055)
• chore(self): leftover probes leave the compiler folder (4dfae8d)
• test(types): probe that a record field is checked against its type (5d6e1bb)
• refactor(scripts): move seed and target scripts from shell to plans (931abaa)
• fix(checker): rebuild or refuse a checker binary older than its source (d0e29ea)
• refactor(probes): run the probe sets from plans (17f9e1a)

Ещё 266 правок языка снаружи не меняют.

0.7.23 — 29 сентября 2026

• chore(release): point the Homebrew tap at 0.7.23 (dcfd766)
• chore(release): the Homebrew formula knows the 0.7.23 archive hash (63647fa)
• chore(release): version 0.7.23 and its release notes (4451f43)
• build(seed): reseed the runtime mirror after rebase (21bd739)
• test(probes): prove the probe without the trust key (8b3b064)
• fix(modules): stop the module search at the tree root (acead8c)
• build(seed): reseed the runtime mirror after rebase (d059cfb)
• build(seed): take the runtime mirror of dev before reseeding (3a20d84)
• test(probes): prove the probe without the trust key (c6aa522)
• chore(numbers): sync measured counts after rebase (77dfdf9)
• fix(runtime): reclaim deep interpreter state and cap run memory (3922b0e)
• chore(seed): reissue corpus records and ceilings for the printed seed (65fb18e)
• build(seed): print the seed with rule names, field types and verbatim literals (94dea99)
• fix(record): print string literals verbatim in record terms (6dcfad4)
• fix(types): check a record field with fits, not with equal carriers (e9d7daa)
• build(seed): print the seed that names the kernel rule at every step (35b11a7)
• feat(proof): name the kernel rule at every proof step (cd000cf)
• build(seed): reseed the runtime mirror after the memchr search (705646d)
• perf(runtime-c): find split and contains candidates with memchr (f697edc)
• chore(tables): re-take the inference rule digest after rebase (cfe9ccf)
• fix(checker): read and check the kernel rule named on a step line (55fce5e)
• fix(checker): read string literals verbatim and nullary module calls (dd8230a)
• fix(checker): stop false lies on the stdlib and close two holes (9659db5)
• fix(checker): read short cases and parametric sum types (0b58b31)
• fix(checker): read the follows theorem header as the language does (e32d12c)
• chore(numbers): sync measured counts after rebase (a2ab45d)
• feat(settings): read English keys in the settings file (228ac8b)
• refactor(guards): check the trust debt with a plan (8a5bbe0)
• fix(io): answer a host timeout with FLANG_IO_TIMEOUT, not a kill (0196605)
• feat(rules): prove three ring laws and ban three false ones (289f703)
• test(parser): measure the parse round trip with a plan kept in the tree (7e4634d)
• fix(check): exit 3 in strict mode when there is nothing to prove (97d65cb)
• Два красных сторожа ствола сняты: комментарии в .flang и слово имени файла (1435) (5190e47)
• Правила Н6 и О9 переигрывает независимая проверяющая программа (1435) (1043ff8)
• Пробы силлогизма сведены с языком и вписаны в CI (5309) (dbad46e)
• Семя догнало источник: ключ предела шагов знает и двоичный из клона (afe09a0)
• feat(9902): предел шагов стал ключом бинарника — печать больше не требует пересборки (bcc99fd)
• Семя догнало источник: раздел о шагах есть и в собранном из клона двоичном (33739be)
• Ведомость называет правило и основания у каждого шага доказательства (3464) (a198499)
• Отказ по недоказанности называет утверждения поимённо, с причиной (2363d95)

Ещё 50 правок языка снаружи не меняют.

0.7.22 — 25 сентября 2026

• Кран Homebrew поднят на 0.7.22 (7b805e7)
• Формула Homebrew знает хеш архива 0.7.22 (0190f16)
• Семя знает свою версию 0.7.22, заметки выпуска написаны (8f0901f)
• Версия 0.7.22: перепечатка дошла, цена самосборки измерена (508cada)
• 1428: двенадцать упоминаний старых имён, набежавших за время ожидания печати (5ed7fbb)
• Два имени печати переименованы на английский: стек инструментов (1428) (6c8ad03)
• Семя напечатано заново: 43 771 519 байт, цена самосборки измерена впервые (6f98e66)
• fix(пробы): каталог программ в новых наборах зовётся programs, а не программы (4d47b39)
• fix(партия): наборы проб партии названы по-английски, имена шагов CI возвращены (41512a2)
• docs(ADR): черновик силлогизма стал ADR-0047 — 0046 занят переименованием flang/proof (92e4c63)
• feat(словарь): поручение «Размер экрана» и отклик «Экран» — двадцать третье слово (848ab79)
• fix(zapis): скобки вокруг дизъюнкции в «Это заголовок функции записи» (8455) (61736da)
• feat(пробы-силлогизма): правка «таких что» ПРОВЕРЕНА прогоном — A/B на одной печати компилятора в JavaScript (0f16ced)
• test(пробы-силлогизма): фальсификатор снят тремя изъятиями — дыра названа поимённо и поставлена под храповик (be985c7)
• fix(ADR-0046): «род» снят — замер занятости говорит, что слово сломало бы 43 места корпуса; входит одно слово, «следует» (71b7741)
• feat(грамматика): силлогизму дают два слова поверхности — «род» и «следует», и чинится распаковка «таких что» (33859c9)
• fix(доказательства): сверщик не пускали на порог — 24 «провала» правил были одним отказом (6c49dac)
• 1416: 77 отставших объявлений пересобраны из таблицы (edf9a3c)
• docs(зеркало процессов): docs/flang/conc → docs/flang/concurrency — три файла, 11 самоссылок, 3 ссылки README (#126) (0597110)
• Справка: латиница основная, кириллица синонимом — 25 вхождений стало 15 (#118) (57f689d)
• docs(readme): три прозаических README у кода стали указателями, проза — в docs/ (fc2be69)
• Диагностики тоже называют латинскую форму: 6 строк (c6e6da2)
• Справка печатает латинскую форму ключа основной, русскую — синонимом (44ac573)
• fix(lean): прогон снова собирается — цикл сборки звал кириллические имена, которых нет с bc962bb38 (9b85a92)
• Задачник актуализирован прогоном: 22 задачи закрыты, 25 вернулись в свободные (#110) (3810506)
• refactor(proof): расширение записи доказательства стало «.record» — 540 файлов и одна строка сверщика (1e83b74)
• refactor(proof): 620 имён файлов набора проб переведены на английский по одному словарю (5d38e3b)
• refactor(proof): пятнадцать каталогов записей названы по существу пробы, а не меткой ячейки (2766f40)
• refactor(proof): каталог доказательств назван по-английски и разложен по родам (#107) (bc962bb)
• Недоказанным управляют из .flangrc: у ключа «недоказанное» три исхода, и строка называет тот ключ, который набрали (d249dd3)

Ещё 71 правка языка снаружи не меняют.

0.7.21 — 21 сентября 2026

Недоказанное не запускается молча: flang run и flang io считают вердикт до работы и отвечают кодом 3, если обещание закрыто только примерами. Пропуск — ключом --на-веру.

Двоичный хозяин читает среду и доводы вызова, и у него появился экран — управляющий терминал.

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

• Формула Homebrew и кран получили sha256 собранного архива 0.7.21 (04f51a6)
• Выпуск 0.7.21: недоказанное не запускается молча, у двоичного хозяина появились среда и экран (57175dc)
• Независимый сверщик перестал звать честную запись ложью: «не взялся» отделено от «поймал», реестр доказанных не зависит от порядка печати (задача 4416, написано поверх разреза на мелкие функции) (3485ec3)
• fix(экран, справка): экран и среда сведены в одном хозяине — справка печатается тремя частями (70a1d07)
• Экран двоичного хозяина: «Показать» и «Ждать событие» на управляющем терминале (0e85caa)
• docs(храповик): расход разреза на мелкие функции записан, потолок не тронут (5749c33)
• refactor(чекер): сверить, без_теоремы и main — по своим мелким функциям (99c784c)
• refactor(чекер): ход_закрытия и домен узла algebra — мелкими чистыми функциями (17b3513)
• refactor(чекер): оценить_терм — разборщик форм отдельно от счёта значений (27a7a50)
• refactor(чекер): шаг_вывода разрезан на 30 правил, каждое — своя функция (6397f12)
• refactor(чекер): из доверенной базы убраны комментарии, не объясняющие решения (b93b197)
• Двоичный хозяин читает среду и доводы вызова: два поручения словаря перестали отвечать FLANG_IO_UNKNOWN (26b18b8)
• fix(нарушения): расхождение вердиктов C ↔ Lean закрыто — строка помечена датой, счёт 3 → 2 (81d54aa)
• Четыре покрытия вместо одного числа: вердикт больше не выдаёт долю записей за доказанность языка (3652fe1)
• Приёмка Lean догнала проверяющего: одновременная подстановка доказана, расхождений вердиктов снова ноль (задача 2844) (a5609e3)
• Строгий режим разводит четыре исхода кодами: ложное постусловие с примерами больше не даёт нуля (задача 5502, пункт 5 внешнего аудита) (ce5896f)
• fix(приметы, опись): числа сведены с деревом после переноса на main 7b072fb42 (404c4ec)
• Независимый сверщик больше не принимает ложное доказательство: подстановка доводов идёт разом, подстановка тела спрашивает захват (задача 2844, пункт 3 внешнего аудита) (67c14ef)
• Уборка репозитория по словам владельца: 4966 строк комментариев из кода, четыре мёртвых документа, симлинк tasks, и долг битых ссылок закрыт целиком (7b072fb)
• Задача 1401: две дыры сличителя перевода закрыты — сперва подделки, потом починка (553f593)
• fix(ведомость правил, сайт): 108 опор правил вывода и счёт теорем сведены с деревом после правки ядра задачи 7563 (5d46040)
• Семя пересеяно быстрым путём: двоичный несёт правку хозяина, отпечаток назван коммитом (e55e086)
• Двоичный отказывает недоказанной программе кодом 3 и знает ключ согласия: хозяин на C зовёт вердикт (задача 6427, ADR-0045 §9 пункт 1) (6fbdffc)
• Семя партии №2 напечатано: вердикт при запуске и сличение с переименованием доехали до двоичного (12a785f)
• Партия семени №2: комментарии сняты из десяти .flang, доводы перенесены в задачи 8222 и 7563 (8e0fd56)
• test(7563): восемь ложных проб на правила аудита и раздел «до/после» в задаче (52133f2)
• fix(ядро): сличение с переименованием идёт в обе стороны и со свежестью, «есть такой» — в списках связывателей (задача 7563) (aff9ec5)
• Запуск говорит, доказана ли программа: flang run и flang io печатают вердикт и без --на-веру не считают недоказанную (задача 8222, ADR-0045) (d51e5b2)
• 2159 Ш1: основания правил вывода сведены в таблицу — сверщик 7531 → 7433 строк кода (b0e155c)

Ещё 37 правок языка снаружи не меняют.

0.7.20 — 18 сентября 2026

доля 650 из 650, вердикт ДОКАЗУЕМ

• Формула Homebrew и кран получили sha256 собранного архива 0.7.20 (d36c0b7)
• Печатнику страницы выпусков поднят предел шагов: заметка 0.7.20 удлинила разбор (выпуск 0.7.20) (c1bbdda)
• Семя пересеяно под 0.7.20: копируемая часть обновлена прибором, отпечаток называет коммит (875e79f)
• Выпуск 0.7.20: номер поднят в шести местах, заметки на двух языках, числа сайта и журнал сведены с деревом (bd8cd1e)
• Хвосты переименования в .fscript: три длины постоянных сведены, плагин asdf догнал дерево (задача 1415) (2ef5ade)
• Переименование в .fscript задело три пробные программы — записи доказательств пересняты, ложь подделок цела (задача 1415) (b3f4043)
• Скрипты носят расширение .fscript: 90 файлов переименованы, 230 читателей сведены (задача 1415, ADR-0043) (722ab95)
• feat(расширения): .fscript — второй закрытый список, 44 места отбора называют оба целиком — ждут 5 (0c644e2)
• docs(ведомости): у восьми tsv первой строкой шапка «ЧТО / ЗАЧЕМ / КТО ЧИТАЕТ», docs/javascript-checks-breakdown.tsv снесён — шапок 8 из 8, снос 1 с доводом, читателей 9, коды до/после те же (002a61b)
• proof(lean): ловушки 55 и 56 — гипотеза без себя в открытых отвергнута; ход работы в задаче 3846 (c2784b6)
• proof(lean): ГипО и ГипД получают леммы — строк ведомости с леммой 109 из 109 (задача 3846) (8fe1094)
• Сто процентов взяты и записаны там, где их будут искать: задача 5190, дорога до ста и ROADMAP правлены по прогону, четыре ссылки в никуда починены (c983627)
• Сторожа сведены с новым семенем: шесть подделок перевыпущены, законное расхождение печати названо четвёртым, компилятор внесён в места отбора по расширению (ed53dff)
• Семя перепечатано из чистой копии: происхождение восстановлено, доля 633 → 639 из 650 (задача 5190) (bfcec7c)
• package.json выброшен из дерева: читатели переведены на .flangrc и emit-package.flang, сторож не даёт файлу вернуться (задача 3570) (bd2c5ca)
• fix(храповик): проб на подлог 517 → 529 над main с 3449 и 7359 — снято прогоном набора на слитом дереве (ef9d4d4)
• proof(сверщик): три закона склейки строк проигрываются формой, а переписка по доказанному утверждению — ходом Переп1 (d643b3f)
• proof(lean): склейка строк — моноид и замена равного равным: леммы Скл1–Скл3 и Переп1 приняты, ловушки 80–84 Lean отвергает (7580031)
• proof(lean): О6 и Ч5 в приёмке Lean — окружение знает, что числа языка представимы, модель терма переводит число в текст; покрыто 76 правил из 81 (26296eb)
• proof(lean): Т2, Э5 и Э6 в приёмке Lean — модель терма знает ярлыки функций и отображение, покрыто 74 правила из 81 (595fd7e)
• refactor(ярлыки): одиннадцать целей flang/proof и перевода объявлены в своих скриптах — сборщик сличил 131 из 144 знак в знак (f49d112)
• fix(сторожа): сторож комментариев зелен на main и зовётся в CI — 14 файлов без прибавки, 64 строки долга с причиной (5c490fd)
• fix(храповик): проб на подлог 514 → 517 над main 385db377c с 7359 — снято прогоном набора на слитом дереве (87baf41)
• fix(храповик): строки кода 3449 — 7401 → 7475 над main с Т2/Э2, проб на подлог 511 → 514 (9c7a7e5)
• proof(сверщик): вычислитель примера разбирает посчитанный список по звену и вариант с полями — три шага corpus-cforms проверены (3449) (2458d52)
• fix(lean): ловушка 32 отвергается за ложное утверждение, а не за второе объявление «разборСуммы» (20100a9)
• fix(приметы): над main b72e6ba9b числа прозы сведены с деревом — файлов .flang 993, строк оболочки 23995, сверщик.c 11468 строк (1d5e829)
• test(сверщик): семья «строка по знакам» — склейка разложения переиграна кодом 0, три порчи отвергнуты кодом 1, подделки ядром не доказаны (a090029)
• chore(потолки): сверщик 7401 → 7409 в счёт ADR-0040, ядро решений 5032 → 5068 с записанным доводом (792a299)
• proof(ведомость, lean): Тожд3 и Инд4 — строки ведомости, леммы «Тожд3», «Инд4», «Инд4-знак» и ловушки 60, 61; Lean отверг 34 искажения из 34 (a135618)
• proof(ядро): строка читается списком знаков — склейка разложения есть сама строка (Тожд3), свёртка по знакам строки-параметра получает принцип свёртки (Инд4) (60ed6ee)
• fix(сверщик): Т2 и Э2 не принимают цель, в которой имя цели свободно в свойстве — две подделки отвергнуты кодом 1 (6c9690b)
• test(сверщик): подделка тела К1 отвергнута кодом 1 — Разв2 расходится с выводом Э1; опись и карта целей сведены с новой целью (348eacf)
• proof(карта): цель К1 записана квантором по элементам — ядро закрывает её правилом Э1, сверщик переигрывает вывод вместо счёта замкнутой цели (46459a4)
• chore(узел): напечатанный flang/concurrency/wire.js снят — свидетелей и узел держит свежая печать (72d7020)
• chore(узел): напечатанный flang/concurrency/link.js снят — свидетелей и узел держит свежая печать (2a7e5a8)
• chore(узел): напечатанный flang/concurrency/scheduler.js снят — свидетелей и узел держит свежая печать (10218b3)
• fix(перевод): сличитель собирается на раннере GitHub — буферы сборки вмещают самую длинную строку, gcc 13 не видит усечения (98518fe)
• fix(сверщик): сборка снова зелёная — стороны формулы в «то_же_отношение» названы «зл» и «зп», и перепись мест отбора по расширению («фп|фланг», file-extensions.flang) сверщик своим местом не числит (72e7803)
• fix(приметы): над main 321843ce числа прозы и опись сведены с деревом — ведомость 227 строк, сверщик.c 11 448, flang/self 139 218 строк и 5151 пример, оболочка 24 564 и долг 15 961, C 835 825 (91527e8)
• fix(ловушки, lean): искажения ADR-0042 — 27–32, после Э5, Э6, Яр1 (24–26); приёмка Lean — 71 правило из 81 приёма сверщика, Т2, Э5, Э6 названы непокрытыми (845ac1e)
• proof(lean): Разв3 принят приёмкой Lean — своё тело по факту «результат равен телу», вызов по факту «функция равна своему телу»; теорема состоятельности для 71 правила из 78 (3d05d9c)
• fix(сверщик): комментарии приёмов ADR-0042 ведут к своим ловушкам — Пр1 24, М1 и М2 25 и 26, К↑ 27, Разв3 28, Разв1 для суммы 29 (88b702f)
• proof(lean): суммы автора в модели терма — К↑ и Разв1 для суммы приняты приёмкой Lean; довод-вызов без сорта; теорема состоятельности для 70 правил (44ea81b)
• proof(lean): списочная свёртка — терм модели, М2 принят приёмкой Lean — мера свёртки с пустого начала, шаг «добавить|приписать Х к а»; теорема состоятельности для 68 правил (28baa4e)
• proof(пробы): место poddelka-svyortka-shagom переиграно на печати зонда — М2 с шагом-вызовом «Дописать нуль», своё тело — Разв3; порча «Удвоить» — код 1 (58410b3)
• proof(пробы): места poddelka-strict-order и abilities У3 переиграны на печати зонда — семья «мера»: М1 и М2, четыре порчи с причиной (0534cba)
• proof(пробы): место abilities У23 переиграно на печати зонда шагом Пр1 — оба места семейства Пр сняты с калькулятора (1a6db81)
• proof(lean): М1 принят приёмкой Lean — мера прибавления против округлённого «плюс 1», вторая сторона — литерал меньше 2⁵³; теорема состоятельности для 67 правил (45c3cec)
• proof(пробы): места equality Р1 и types Т1 переиграны на печати зонда — семья «развёртка»: К↑, Разв3 и Разв1 для суммы, восемь порч с причиной (bc251f5)
• fix(lean): нечитаемая цель — у блока и у постусловия — и шаги после первого шага вне приёмки получают заглушку: блок с целью-разбором суммы уходит «вне приёмки», а не «не прочёл» (4041ad7)
• chore(храповик): строка бюджета ADR-0042 +180, съедено 166 (7179 → 7345) — потолок поднят ровно на съеденное, 7263 → 7429 (ac331ee)
• proof(пробы): место poddelka-protivorechie переиграно на печати зонда шагом Пр1 — семья «противоречие», пять порч с причиной (787d46f)
• proof(печать): ядро печатает выводы Пр1, М1, М2, Разв3 с К↑ и Разв1 для суммы — в семя это доедет перепечаткой (5190) (9f66098)
• proof(сверщик): вычислитель примера держит нулевой знак и считает отбор — corpus-bytes проверен целиком, доля на стволе 629 → 630/651; у corpus-cforms следующая стена названа (2a3ba99)
• proof(сверщик): Пр1, М1, М2, К↑, Разв3 и Разв1 для суммы переигрываются сличением — цель-разбор читается всеми строками (ec0bf26)
• proof(ведомость, lean): семейства Пр и М, Разв3, К↑ и Разв1 для суммы — пять строк ведомости, леммы и ловушки 24–29; Пр1 принят приёмкой Lean, теорема состоятельности — для 66 правил (8d33d30)
• feat(печать): квантор по элементам печатается в C и C++ циклом, который встаёт на первом «нет», и сличитель переигрывает его правилом «все-элементы» (5461435)
• feat(печать): квантор по элементам печатается в Go, Rust, Java, C#, Elixir, Python, JavaScript и TypeScript той же свёрткой, что у вычислителя (79575c7)
• docs(приметы): числа в прозе сняты заново над a2015b08 — ветка прибавила 8 файлов .flang и сдвинула списки parser.flang на 5 строк (321843c)
• proof(пробы): запись сквозной переснята печатью с блоком снятия — место «Две» в записи, вывода в блоке нет (4058, ADR-0038) (e1b65f4)
• proof(lean): читатель записи читает [] пустым списком — сверка вердиктов сошлась, расхождений 0 (4058) (7128d96)
• docs(proof): семейство Э и Яр1 описаны в SPEC и README семьи, исполнение ADR-0037 §4.3 и §4.5 записано; задача 4058 сделана (9ff1694)
• feat(proof): Яр1 на месте вызова — обещание «Ф» берётся о применении её ярлыка, сквозная ADR-0037 §3 доказана целиком (4058) (55d5ec5)
• proof(ведомость): Яр1 — строка ведомости и лемма Lean с ловушкой 26; Э5 и Э6 сверены с кодом (4058) (c1f7def)
• perf(ядро): Э5 решает функция Э3 — «Выписанное всё» снята, ядро решений 5048 → 5032 (4058) (6367758)
• feat(proof): Э5 и Э6 в ядре, печати и сверщике — выписанный список и отображение выводятся по построению (4058) (32c8cbd)
• proof(ведомость): Э5 (выписанный список с головой) и Э6 (отображение) — строки ведомости и леммы Lean (4058) (a849a2b)
• feat(proof): в требует читается квантор по элементам — цель-тождество закрывается Т2, сверщик её переигрывает (3123) (d3783d6)
• refactor(дерево): модель процессов живёт в flang/concurrency — flang/conc переименован, 66 файлов (5ce665a)
• refactor(дерево): проводник по языку живёт в flang/bin/flangtutor, а не в корне дерева (d2b4089)
• refactor(дерево): проверки на flang живут в flang/test — flang/проверки слит туда, 26 файлов (93c9db7)
• test(сверщик): precondition.flang печатью ядра дерева — оба места корпуса проигрываются; опись и примета сведены с деревом (6fa73f5)
• fix(печать): литерал снятия печатается листом Н1 сам — на precondition.flang печать больше не упирается в предел шагов (bb70b25)
• docs(ADR-0038, 1729, доля): предусловие как обязательство — вторая доля 629/653 названа рядом с первой, «никогда» 1729 отменено для обязательства (fffff27)
• test(сверщик): семья «снятие предусловия» — три подачи довода проигрываются, пять подделок отвергнуты (6d11bac)
• perf(ядро): узел снятия собирается прямо в круге — достижимое от поверхности снова 8696, ядро решений 5017 (365dcf4)
• proof(ядро, печать): снятие предусловия — обязательство записи precondition-at-call, запись печатает его блоком с выводом (5fc9e99)
• proof(доля): рядом с долей постусловий печатается доля с предусловиями — 629/651 и 629/653 (60a2005)
• proof(сверщик): снятие предусловия на месте вызова читается и переигрывается прежними приёмами (d9dd94b)
• proof(ведомость): у Разв2 плоскость — нет вызова объявленной функции, вызов довода-функции разрешён; ведомость и приёмка Lean говорят то, что делает сверщик (b337a07)
• docs(proof): теорема о состоятельности приёмки есть для 65 правил из 73 — дорога §3 и lean-checks §7 числом, 1130 сделана, 8836 — 18 блоков (784fcd8)
• docs(lean): шапки Приёмка.lean и Состоятельность.lean — 65 правил из 73 поимённо, восемь непокрытых с причиной, где модель строже и мягче сверщика (c07fae5)
• proof(lean): Д3 в приёмке — дно суммы — сумма написанных днов слагаемых; теорема для 65 правил из 73 (31d4c7e)
• proof(lean): О5 в приёмке — общая прибавка-число, литерал либо имя в отрезке, сохраняет порядок; теорема для 64 правил из 73 (5e715a6)
• proof(lean): Н8 в приёмке — произведение неотрицательно, когда один сомножитель в (0, кон], а второй не меньше нуля; теорема для 63 правил из 73 (bed384c)
• proof(lean): Н7 в приёмке — свёртка неотрицательна при неотрицательном начале и шаге, держащем знак накопителя; теорема для 62 правил из 73 (70fa675)
• proof(lean): Кон2 в приёмке — оговорка «пока это число» снимает гипотезу «( Т минус Т ) равен 0»; теорема для 61 правила из 73 (6e75af4)
• proof(lean): СС4 в приёмке — выбор не убывает при неубывающих ветвях либо при ветви «иначе», закрытой охраной-допущением; теорема для 60 правил из 73 (36f4514)
• proof(lean): СС3 в приёмке — приписать к неубывающему списку, чья голова по построению не меньше приписанного; теорема для 59 правил из 73 (33c7260)
• proof(lean): у второго способа СС4 и у Д3 с днами-литералами есть леммы в Правила.lean (7718505)
• proof(lean): СС2 в приёмке — «Л не убывает» — допущение строки знак в знак; теорема для 58 правил из 73 (4b81e1b)
• proof(lean): Д4 в приёмке — дно выбора не выше днов обеих ветвей; теорема для 57 правил из 73 (12d3185)
• proof(lean): С3 в приёмке — литерал строго ниже дна верхней стороны; теорема для 56 правил из 73 (7f64972)
• proof(lean): С2 в приёмке — выбор строго меньше Г, когда обе ветви строго меньше Г; теорема для 55 правил из 73 (2ea93d3)
• proof(lean): О3 в приёмке — выбор не больше Г, когда обе ветви не больше Г; теорема для 54 правил из 73 (f70388b)
• proof(lean): Ч4 в приёмке — выбор начинается с приставки обеих ветвей; теорема для 53 правил из 73 (49dcb0c)
• proof(lean): В4 в приёмке — элемент содержится в выборе, когда содержится в обеих ветвях; теорема для 52 правил из 73 (d37feb6)
• proof(lean): В3 в приёмке — вхождение сохраняется при «добавить» и «приписать»; теорема для 51 правила из 73 (203d78b)
• proof(lean): Ч3 в приёмке — склейка начинается с приставки своей левой части; теорема для 50 правил из 73 (9365141)
• proof(lean): О10 в приёмке — порядок переходит через названную середину; теорема для 49 правил из 73 (f7f8795)
• proof(lean): О4 в приёмке — литерал не выше дна верхней стороны; теорема для 48 правил из 73 (501eb66)
• proof(lean): О8 в приёмке — отбор не удлиняет список; теорема для 47 правил из 73 (3be9168)
• proof(lean): Д5 в приёмке — дно произведения — произведение написанных днов сомножителей; теорема для 46 правил из 73 (f438c69)
• proof(lean): Ч6 в приёмке — начало переходит через названную середину; теорема для 45 правил из 73 (c1d7a3c)
• proof(lean): Ч2 в приёмке — всякий текст начинается с пустой приставки; теорема для 44 правил из 73 (ca0f380)
• proof(lean): С4 в приёмке — литерал не выше строгого дна, взятого строкой либо шагом; теорема для 43 правил из 73 (34a1e2b)
• proof(lean): О2 в приёмке — терм не больше самого себя при неотрицательности либо конечности; теорема для 42 правил из 73 (d703168)
• proof(lean): П6 в приёмке — остаток целого неотрицательного от литерала Д не выше Д − 1; теорема для 41 правила из 73 (b7250bf)
• proof(lean): Н10 в приёмке — остаток целого неотрицательного от ненулевого литерала неотрицателен; теорема для 40 правил из 73 (43501d3)
• fix(lean): читатель записи берёт основание «из N M K» и шаг вне приёмки с формулой, которой не знает, — сверка вердиктов снова без расхождений (3ba2e82)
• proof(lean): С1 в приёмке — строгий порядок из допущения строки в любой из двух записей; теорема для 39 правил из 73 (6054f39)
• proof(lean): Д6 в приёмке — написанное число есть дно самого себя; теорема для 38 правил из 73 (1567164)
• proof(lean): Д1 в приёмке — дно из допущения «⟨литерал⟩ не больше Г» в любой записи порядка; теорема для 37 правил из 73 (6cd2dcc)
• proof(lean): В1 в приёмке — выписанный список содержит свой член знак в знак; теорема для 36 правил из 73 (f40c3c1)
• proof(lean): Ч1 в приёмке — текст начинается с самого себя; теорема для 35 правил из 73 (e7360e2)
• proof(lean): В2 в приёмке — положенный элемент содержится в «добавить Э к Л» и «приписать Э к Л»; теорема для 34 правил из 73 (b612968)
• proof(lean): О1 в приёмке — порядок из допущения строки в любой из двух записей; теорема для 33 правил из 73 (6b998de)
• proof(lean): СС1 в приёмке — выписанный список без пар соседей не убывает; теорема для 32 правил из 73 (fe23c26)
• proof(lean): у Или1, Или2, И1, И2, Цел1, Цел2 есть леммы в Правила.lean и ловушки; Цел1 и Цел2 в приёмке — теорема для 31 правила из 73 (8817e25)
• feat(перевод): сличитель на C переигрывает протокол перевода, шестнадцать опытов сходятся с ожиданием (6ebd5e1)
• feat(печать-c): печатник ведёт протокол перевода по ключу «--протокол», без ключа C выходит прежним байт в байт (cb94b08)
• proof(сверщик, печать): прибавка-имя у О5 и О6 переигрывается шагами «из N M K» — после перепечатки 639/651, на ветке 629/651 (f8c6419)
• proof(пробы): оговорка, точный текст и разбор выписанного переиграны на печати зонда — корпус остаётся печатью семени, 629/651; после перепечатки 635/651 (9766378)
• proof(сверщик, печать): Кон2, Ч5 и Разв1 переигрываются шагами вывода, тело в несколько строк — ходом развёртки (97ca726)
• proof(lean): вердикты сверщика и приёмки Lean сверены на всём наборе проб — 1291 блок «вывод», расхождений 0 (3e38043)
• proof(lean): тело и вызов любого сорта — терм читает список, текст и признак, Разв2 подставляет тело своего сорта (995662d)
• proof(lean): теорема состоятельности «Принят → Судим окружение цель» для 29 правил из 70 приёмов сверщика (641d3be)
• proof(lean): приёмка блока «вывод» — «Принят» и разрешимая «принят?» для 29 правил, «принят?-верно» доказана (8086b69)
• proof(lean): запись доказательства, исходник и окружение утверждения — данные Lean (4d5ec98)
• proof(lean): терм языка — данные Lean; леммы семейств Н, П, Т, Э переформулированы через «оценить» (42219fd)
• perf(ядро): факты снятия приезжают в «Место снято» данными, обход вызовов один — ядро решений 5259 → 5017 (aed085c)
• proof(ядро): снятие предусловия читает объявленные типы и доказанные обещания вызванных, кругом до неподвижной точки (c12209f)
• Запись подделки svyortka-nad-pustym перевыпущена: ядро печатает больше (3e8619e)
• Аксиома вне довода, потолок доверия и восемь чисел README (a47409d)
• Закрыть два конфликта, которые ушли в коммит незакрытыми (08170e4)
• Цель JS кладёт манифест узла рядом с выводом; версия и имя заведены в .flangrc (f111c5a)
• docs(flang): из перенесённых документов снят слоп, 14 599 → 14 555 строк (25c58dd)
• refactor(дерево): ссылки зовут документы по новым путям, а рядом с кодом стоит указатель (fd93823)
• длинная арифметика: сложение, вычитание, сравнение, столбик и Карацуба (18e7956)
• ADR-0032: квота на рост верификатора поднята с +50 до +110 по замеру (0b67242)
• документация приведена к дереву 0.7.19 (4c59b0d)
• описание языка: проза приведена к примете после третьего слияния (6d79e1e)
• состояние во времени слито в ствол; приметы и опись пересняты (3e3f4ed)
• 1404-Ш1: утверждение о прогоне закрывается индукцией по списку свёртки (ce57280)
• эффекты и владение слиты в ствол; приметы и опись пересняты один раз (73f6391)
• feat(processes): обработчик процесса обязан принимать РОВНО своё состояние (1406 Ш0) (94c1217)
• сверщик судит план: правило Пл1 и семья проб «план» (1405 Ш0) (8d4c4e4)
• перепечатка семени: четыре места остатка доехали до двоичного — 625/651 → 629/651 (41c80e4)
• Строгий режим строк кванторов и объявления включён: СТРОКИ_КВАНТОРОВ_ОБЯЗАТЕЛЬНЫ 1 (партия перепечатки); прогон.sh гоняет строгие пробы на самом сверщике и сторожит переключатель. ВЛИВАТЬ ТОЛЬКО ПОСЛЕ ПЕРЕСЪЁМКИ ЗАПИСЕЙ ПЕЧАТЬЮ ЯДРА (99cc046)
• ведро Е, печать (черновик E-4, ADR-0027): блок «вывод» для разбора цели по условию — ГипО + Р5/Р6 | С4 | Кон3→О2 + Разв2 + Р1; по внутреннему условию — Выч×2 + Р3 + Разв2; по дизъюнкции в допущении — ГипД (+П2/Или1/Или2) ×2 + Р4 + Разв2; «Строки утверждения» зовут «Вывод записи по объявлению» (826ed09)
• приметы: примеров flang/self 4670, строк 131 569 после проверки замыкания в С1 (b620c74)
• запись: семья С1 «соседи» тоже печатает только замкнувшуюся цепочку (0c8a2e2)
• опись: storefront.flang (16|10|6) и markup-without-logic.flang (3|1|2) в proved-share-ledger; приметы чисел пересняты 2026-09-08 (4374478)
• react-ts-pure: ЗАМЕР.md — бандл и Web Vitals против react-invoice и vue-roman; строка в README примеров фреймворков (6ae8e8b)
• examples/frameworks/react-ts-pure: витрина на flang под React + TypeScript, в компонентах ноль строк логики (906484a)
• феат(сверщик): вариант А — первая именованная аксиома «неотрицательность по построению» в числитель доли (088b019)
• refactor(stdlib): убрать комментарии и дубли (a151e1a)
• fix(ядро): классификатор обхода берёт весь список расширений (d65bfa5)

Ещё 218 правок языка снаружи не меняют.

0.7.19 — 13 сентября 2026

• выпуск 0.7.19: отпечаток архива пересчитан по сборке, кран поднят (1218aa1)
• выпуск 0.7.19: версия поднята, заметки записаны, семя пересеяно (446b707)
• исправлено разрешение слияния: девять файлов взяты от ствола (b76dfe6)
• после слияния: отпечаток снят прибором, приметы пересняты, адреса починены (82f50fc)
• партия №3: семя перепечатано, записи перевыпущены, зонд 2040 очищен (5ec3a5f)
• семя догнало источник: печать в TypeScript названа справкой (eaf9e25)
• приметы догнали дерево после слияния 2040: файлов flang/self 64 → 65, строк 136 583 → 136 652 (c066ca0)
• 2040: свободное утверждение доезжает до машинной ведомости — три места отсева, не одно (47677d6)
• шаги ведомости: шаг теоремы называет правило и посылки, ядро проверяет (3464) (6f9d54e)
• proof(6206, 5957): квантор по элементам списка и вложенные кванторы (ADR-0026 §11 п.14–15) (e667ecc)
• приметы и проза после Инд1: ведомость 176 → 177 строк, правил 77 → 78, привязка Инд1 к ADR-0026 (276a51a)
• proof(5144): свободное утверждение с чистой целью доказывается ходами и переигрывается (6e42d9a)
• 9526: правило Инд1 — индукция по СВОЕЙ объявленной сумме в свободном утверждении (904100f)

Ещё 11 правок языка снаружи не меняют.

0.7.18 — 12 сентября 2026

• выпуск 0.7.18: отпечаток архива пересчитан по сборке, кран поднят (787f0c0)
• выпуск 0.7.18: номер поднят в семени — двоичный называет себя верно (160d725)
• версия 0.7.18: число разнесено по дереву, кран и плагин подняты (220b991)
• проза SPEC.md догнала примету: строк flang/self 135 392 (24e6edb)
• приметы догнали дерево после снятия мёртвого ввоза в зонде (69b6771)
• зонд кванторов: снят мёртвый ввоз «Печать JSON» — он сводил json.flang и lsp.flang в одно замыкание (edd10e9)
• examples/ уезжает в docs/examples/: опора корпуса 289 → 304, снята прогоном (задача 1745, пункт 3) (95f5789)
• перепечатка партии №2: четыре места остатка доехали до двоичного — 625/651 → 629/651 (f9ed22e)
• package.json ОСТАВЛЕН, три мёртвых поля сняты: это не пакет npm, а единственное место версии, лицензии и двух адресов (задача 1745, пункт 1) (56c42ee)
• scripts/ разложен по каталогам: 136 файлов у корня каталога → 13, остальное по восьми папкам (задача 1745, пункт 5) (2f2f474)
• CI на dev c8103f06d: четыре скрытых красных шага и сайт починены разом, метод — все шаги пяти работ локально подряд (3dec368)
• Опись пола доказанного и три приметы догнали партию №2: opis и proza зелены (cf31704)
• Отпечаток семени не требует чекера; шаг сборки чекера возвращён в guards-selftest (8db0f3a)
• партия №2 собрана: остаток-26 + кванторы (6202, 6203, 6205) + логика (1403, спеки 1404–1406); храповик проб 33/417 → 34/425; приметы пересняты (6b7c43f)
• Свежесть ядра судится содержимым семени, а не временем файлов: отпечаток bootstrap/flang.seed-sha256 (ae42220)
• Линейка снова верит себе: чекер печатает «проверено по телу функции», зеркало пород складывает его — расхождений 3 → 0 (aa229f9)
• 1403 сделана: правило Н12 «разность под записанным порядком»; 1404–1406 — замер, спецификации Ш0..Шn, Ш0 сверщика для 1404 (63ba79b)
• приметы после перебазирования на gh/dev d6e88d50b — по замеру сторожа чисел: файлов .flang 1399 → 1401 (зонд К7, проба «список чисел»), flang/self/.flang 63 → 64, строк-в flang/self 135 070 → 135 118, строк SPEC.md доказательств 4670 → 4699, заметок 666 → 667, файлов доказательств 225 → 226, строк оболочки 23 863 → 23 868 и 24 493 → 24 498; сторож: все 196 примет сошлись (8e4521f)
• proof(6205): существование сверено толкованием на семени 0ce948bfd — ф10к доказано, запись ядра со свидетелем и подстановкой (сверщик 0), факт-со-свидетелем: ядро закрывает «Шесть» сведением без хода «факт по свойству» — рукотворная запись оставлена, печать ядра рядом отдельной пробой; факт-с-чужим-свидетелем — программа верная, подделка только запись; README семьи, ADR-0026 §11 «Исполнение»; задача сделана → completed; прогон.sh честных 198 → 199, подделок 401/0; доказуемость 4 ДА, доля 625/651; в семя не доехало — перепечатка (a560f07)
• proof(6205): узел «exists» доходит до типизатора и вычислителя (ADR-0026 §11 п.7): «Тип существования» в types.flang — свидетель типизируется, имя связывается его типом, тело обязано быть признаком; «Вычислить существование» в interpret.flang — кадр «пусть» над полем witness; зонд zond-k7.flang над flang/self; заметка zettel; bootstrap/flang check types.flang и interpret.flang — код 0; толкованием: ф10к — доказано, запись со свидетелем, сверщик код 0; в семя не доехало — перепечатка (50d23ce)
• proof(6202): И3 сверен на семени 0ce948bfd (pred-zov: обязательство входа и Пред1→П3 печатаются, запись побайтно = дереву); ведомость П3 «сверено» код-шире → код, отпечаток переснят, Lean-комментарий дословно; задача сделана → completed; доля 567/651 (базлайн 9.09) → 625/651, Lean 85 лемм, сверка-ведомости 0 (047a696)
• proof(6203): Ш1 сверен на семени 0ce948bfd (проба «список числа» под «для всех»: носитель algebra с объявления, сверщик 0), Ш3-тексты (SPEC §3г-бис, легенда proof.flang, ЧИТАТЬ.md, ADR-0026 §11 исполнение); задача сделана → completed; прогон.sh честных 197 → 198, подделок 401/0; доказуемость 4 ДА, доля 625/651 (9e6304b)
• Пять правил ведомости, которых не было в приёме «вывод»: Кон1, Н9, О8, второй способ Н8 и СС4 (5bfc39f)
• К3c: «по примеру» в свободном утверждении — три пробы на пример, дыры нет (1621192)
• партия №1: приметы списков в io.flang — parser.flang 6440/6449/6458 → 6589/6598/6607 (пакет сдвинул строки; io.flang — вход печати, правка требует перепечатки) (31bc804)

Ещё 48 правок языка снаружи не меняют.

0.7.17 — 11 сентября 2026

• выпуск 0.7.17: указатель плагина asdf догнал плагин (5a37526) (b52f1c0)
• выпуск 0.7.17: отпечаток архива и кран (9499c30)
• выпуск 0.7.17: язык прошёл собственную проверку на доказуемость (1442084)
• io.flang возвращён: перестамповка залезла в семя (020243c)
• ADR-0030 и задача 1401: печатник доказывает каждый свой запуск (2a0b653)
• Проверка свежести отличает нарочную подделку от отставшей записи и отказывается мерить старым ядром (aae40f7)
• прогон.sh: комментарий у пробы ф09 поправлен по замеру A — запись рукотворная, прежние сборки ядра этот исходник не разбирали; новое ядро не хуже (5cffbd1)
• Партия перепечатки: записи проб под строгий режим, ложь подделок сохранена (c887237)
• после слияния пакета №1: приметы (списки parser.flang 6440/6449/6458 → 6589/6598/6607; строки семени, C, flang/self; примеров-в flang/self 4904) и опись доказанного (6 строк flang/self: «написано» по исходнику, приговор протух по md5; строка link.flang «×»); io.flang — отдельно, перепечаткой 1c (61f3f2c)
• семя перепечатано из b6f3a4b0f (партия №1: И3, Ш1/Ш2, кванторы К1–К12, печать E): sh scripts/raskrutka.sh — РЕПРИПТ КОД=0, «семя годное»; 7 файлов, 41564839 байт; функций 8143, с доказанным завершением 6049; проверок при работе снято 3211; 7 ч 28 мин (старт 02:08:53Z, конец 09:36:56Z) (0ce948b)
• партия №1: снято столкновение имён с types.flang и lsp.flang — в proofterm.flang «Не сошлось» → «Сличение не сошлось» (пришла в eb2deb31d), «Место объявления» → «Место объявления принципа» (fdc14f0be); перепечатка 3249aac39 отказала на этом (FLANG_DUPLICATE_NAME ×2 + 13 FLANG_TYPE) (b6f3a4b)
• плагин asdf ставит проводник; указатель поднят (5a37526) (4bd99b6)
• Страховка №2–5 (сверщик): цель «результат не меньше 0» без теоремы и блока вывода — тело неотрицательно по построению (прямая_по_предположению), в неотрицательно_algebra добавлена свёртка-счёт по Н7; binder-wall-map, corpus-lists, four-words — 0, corpus-hof — одно место; доля 575 → 579; +14 строк кода в счёт «покрытие» (9c24ae4)
• Замер запаса №8 (сверщик): правила Ч1, Ч3, Ч4 по телу функции — «результат начинается с П» без теоремы и блока вывода сверщик проигрывает сам: тело без вызовов начинается с П по построению (литерал, склейка с левым куском, выбор с обеими ветвями); nachalo — одно место снято; +18 строк кода в счёт «покрытие» (702181d)
• К3c в печати партии (сверщик): «вердикт доказано при условии» (к3c-в) узнаётся — место на слове ядра с причиной «опирается на утверждение, доказанное лишь при условии», в реестр не идёт; 3 вместо 1, никогда 0; к3c-б с блоками по строке — 0 (путь хода берёт факт у утверждения); +5 строк кода в счёт ADR-0026 (a3cbf51)
• К3c: блоки записи по строкам исходника — утверждение стоит раньше опирающегося на него постусловия (10a8714)
• Замер запаса №7 (сверщик): правило Ч6 по телу функции — «результат начинается с П» без теоремы и блока вывода сверщик проигрывает сам: тело — вызов «F», у F нет «требует», её «начинается с Б» проверено раньше (реестр), Б начинается с П — сличение литералов; nachalo — одно место снято; +21 строка кода в счёт «покрытие» (ece1390)
• Замер запаса №6 (сверщик): правило О9 по телу функции — постусловие «результат не больше (длина Л)» без теоремы и блока вывода сверщик выводит сам (свёртка с нуля, шаг прибавляет не больше единицы), узлом; corpus-hof — одно место снято; +24 строки кода в счёт «покрытие» (43c6fa6)
• Замер запаса №1 (сверщик): неотрицательно_algebra берёт произведение на выписанное число в (0, 2⁵³−1] (Н8, второй способ) — four-words «удвоенное» проигран; Ч7104 «накрутка» стала честной (шаг проверен по построению), дверь стережёт новая пара с непроверяемым телом; +8 строк кода в счёт «покрытие» (2cc534d)
• ХРАПОВИК доверенной базы: строка «покрытие без новых правил» +100 → +200 (решение overagent'а 10 сентября 2026 по замеру запаса Lead-A), потолок 7038 → 7138 — приём существующих правил таблицы, запас порога до партии, каждое место со своей пробой и фальсификатором (ff4fd1e)
• печать Цел2 (ADR-0029, вторая поправка §4): остаток довода точного типа — целость обязательством зовущего, дно объявлением, Н10/П6 (abilities У13/У14) (a7efe8c)
• Находка B (сверщик): печать партии ф05к носителем algebra над свёрткой — сведение базы «пусто» у свёртки по доводу индукции законно (Р6), Ч2718 больше не зовёт честную запись ложью: код 3 с причиной вместо 1; запись B — в пробы, подделка «свёртка не по доводу» — 1; +10 строк кода в счёт ADR-0026 (d7f3f14)
• партия: одна «Это утверждение» — копия в obligations.flang снята (та же в proof-initial.flang, модуль «Начальная алгебра», ввезён целиком) (3b40708)
• указатель крана поднят: формула крана ставит проводник (8013577) (6ab7ac0)
• проводник по языку доезжает до поставки: архив несёт flangtutor и пять уроков, формула их ставит, состав поставки стережётся (5ecc05c)
• Цел2 в приёме: целость довода точного типа — обязательство зовущего (ADR-0029, вторая поправка §4) (7d81002)
• ADR-0026 К3c (сверщик): утверждение применяется шагом «по свойству «И»» — путь шага (привязка к заголовку, реестр проверенного, сличение цели после подстановки доводов того же типа) и путь хода «факт … подстановка «л» ⟨Т⟩»; одно имя у постусловия и утверждения — отказ; снятие условий в точке хода вынесено в снято_в_точке; +76 строк кода в счёт ADR-0026 (23579d2)
• после слияния Н7/Н8 поверх узла binder-wall-map: проба «Н7: счёт свёрткой под выбором» ждёт 0 (узел A закрыл три прочих места записи, Н7 — четвёртое; запись проиграна целиком); приметы пересняты: .flang 1352→1355, .sh 23618→23628, оболочка 24218→24228, C 797911→797925, курс 192→195 (1922837)
• печать Н7 и Н8 (строки таблицы; покрытие без новых правил): счёт свёрткой — дно начала и Н7 при шаге «накопитель / накопитель плюс литерал / выбор из таких»; произведение на положительный литерал — дно второго сомножителя и Н8 (binder-wall-map, corpus-hof, corpus-lists, four-words) (2f6d921)
• Покрытие, узел binder-wall-map (сверщик): у цели-охраны выбор с тем же условием под охраной есть «да» (Р1, ГипО, Р3), замкнутую цель закрывает Выч — без нового правила; корпус binder-wall-map 3 места сняты со слова ядра; +5 строк кода в счёт «покрытие» (774d85a)
• Н7 и Н8 в приёме (строки таблицы; покрытие без новых правил): свёртка неотрицательна при дне начала и шаге «накопитель / накопитель плюс литерал / выбор из таких», произведение на положительный литерал при дне второго сомножителя; пробы binder-wall-map, corpus-hof (своим именем), corpus-lists, four-words; четыре согласованные подделки (fold-and-product-lies) — без своей проверки каждая прошла бы кодом 0; опись и приметы (f3a3dd2)
• К3/К3c связывание: программа несёт statements (перед theorems, только непустым); утверждения ввезённых модулей доносятся, своё имя сильнее; теорема ввезённого файла едет и за его утверждением; обязательство statement несёт vars узлами разбора со span (44c5764)
• печать Д3 (ADR-0029, поправка §4): дно суммы — дно каждого слагаемого (Д6 у литерала, лист неотрицательности у прочих) и Д3 с написанным дном; «… больше 0» — ещё С3 (boundaries В7/В8/В9, strict-order :95) (a83d5f9)
• Ячейка 4 покрытия не взята — названная причина (сверщик): «вид цели … незнаком» у целей-свёрток называет отбор списка (corpus-cforms ×3) и строку с нулевым знаком (corpus-bytes); коды 3/3 прежние, без причины текст байт в байт; +11 строк кода в счёт «покрытие» (e7f4778)
• Семья «утверждение», README: условие К3b «л не остался в цели» помечено — страховка, пробой не опровергнута (решение overagent'а 10 сентября 2026) (8c96b6a)
• К7/К5 доработка: «есть такой» корнем «утверждаем» теоремы; «результат» в «таких что» постусловия — отказ (5634975)
• Д3: согласованная подделка суммы (собрал Lead-A — цель, Д3 и Разв2 говорят «2», ложна только сумма дон 1 и 0); прежняя подделка помечена довеском — её ловит и Разв2; фальсификатор: сверщик без проверки суммы — проба красна «ждали 1, вышло 0»; опись доказанного и приметы (файлов *.flang 1348) (1f194f6)
• К3c: терм подстановки печатается тотально — лист (имя, число), текст «Термом записи», вызов над листами; «Терм узла записи» не тотальна (FLANG_NOT_TOTAL в check 6485ec7ec) (a7bfa48)
• печать отношений, группа А замера E-m1 (11 мест, приём готов): «не убывает» (СС1, СС1+О1+СС3), «содержит» (В2, В2+В3), порядок меры (Н4+О2, Н4+О4), прибавка к границе (О1+О6), потолок из допущения равенства (П2); «Вывод записи по объявлению»: факт о типе → разбор → отношения (b2e5c04)
• Покрытие, ячейка 5 (сверщик): прямая теорема «по предположению» переигрывается — тело неотрицательно по построению при предусловиях функции, без нового правила (883015b)
• ХРАПОВИК доверенной базы: строка «покрытие без новых правил» +100 (решение overagent'а 10 сентября 2026), потолок 6938 → 7038; расход ячейки 5 +13 (947f274)
• Д3 в приёме (ADR-0029, поправка §4): дно суммы — написанное дно сличается с суммой двух написанных дон, дно в любой записи; пробы группы А и Д3 (abilities, equality, boundaries, strict-order :95) и четыре подделки Д3 в прогоне (91710c5)
• ADR-0026 К3b (сверщик): доказательство утверждения без функции переигрывается — сведением к постусловию функции, которую цель зовёт на связанном имени; утверждения — в описи доказанного (7d13e38)
• К3c печать по окончательному интерфейсу ядра: подстановка — из элемента props вердикта (kind statement, line, subst); привязка шага по свойству — постусловие по имени, иначе заголовок утверждения (6485ec7)
• К3: параметр типа у свободного утверждения — «утверждение «И» от «А»» (typeParams) (060e44b)
• Е-6, печать (черновик): строгая охрана и выбор из двух литералов слева — С4 для каждой ветви, С2, Разв2 (strict-order :130; приём С2 и С4 из шага уже есть) (42ca5fe)
• Пробы К7: ∃ взято фактом «по свойству» — У[м:=Т] с написанным свидетелем закрывает цель; другой терм на месте свидетеля — отказ (796abf2)
• Е-5, печать (черновик, ADR-0029): под охраной цели — расщепление конъюнкции И1/И2, остаток целого (Цел1 + Н10/П6) и дно произведения (Д6 у литерала + Д5); «Шаги отношения под охраной» передают остальное «Шагам арифметики под охраной» (0bbcabc)
• К3c в ядре: шаг «по свойству» прикладывает утверждение подстановкой (eb2deb3)
• ADR-0026 К7 (сверщик): существование со свидетелем — цель «есть такой м, а именно Т, что У» доказывается и берётся фактом как У[м:=Т], подстановку сверщик строит сам (5f46157)
• К3c/К5 черновик печати: «допущение J» у шага — из hypothesisSteps вердикта; связанная утверждения без места — строка ищется под заголовком; шаг по свойству утверждения — ход факта с подстановкой из обоснования шага (f2472bd)
• К3c: одно имя у постусловия и утверждения — FLANG_PROOF_AMBIGUOUS; параметры типа утверждения в области его связанных; обязательство statement несёт typeParams (e01d758)
• приметы после приёма Е-5: строк *.sh 23489, оболочки 24089, C 797649, ведомости 174 (3e99b3d)
• Е-5, приём (ADR-0029): Н10 и П6 (остаток целого из целости Цел1 и дна), Д5 (дно произведения: закон монотонности, написанное дно сличается с произведением двух написанных дон), дно в двух записях; двенадцать подделок и две пробы в прогоне (5472963)
• ADR-0026 К3a (сверщик): утверждение без функции — блок «вид statement» сверяется по структуре; доказательство — на слове ядра до К3b, никогда 0 (b0834b8)
• К2/К3/К5/К6/К7 разбор: все кванторные ячейки ADR-0026 §11 (parser.flang) (c0f5c52)
• К3 запись: обязательство утверждения проходит отбор входного файла по своему имени (у него of пусто) (0618377)
• Е-5, приём (черновик, ADR-0029): Цел1 (целость из факта остатка) и И1/И2 (расщепление конъюнкции); строки ведомости И1, И2, Цел1, отпечаток; С-2: правил из ADR 67 → 70; эталонные записи восьми мест в семье «вывод/р» (8987480)
• ХРАПОВИК доверенной базы: бюджет ADR-0029 (арифметика под условием, Е-5) +150 строк кода, потолок 6788 → 6938 — строкой таблицы вслед за ADR-0029 §3.5 (9e529ac)
• ADR-0026 К5 (сверщик): «таких что» постусловия, допущения теоремы, шаг «по предположению допущение J» сличаются с исходником — ограничение больше не теряется молча (37398ea)
• ведро Е, печать (черновик E-4, ADR-0027): блок «вывод» для разбора цели по условию — ГипО + Р5/Р6 | С4 | Кон3→О2 + Разв2 + Р1; по внутреннему условию — Выч×2 + Р3 + Разв2; по дизъюнкции в допущении — ГипД (+П2/Или1/Или2) ×2 + Р4 + Разв2; «Строки утверждения» зовут «Вывод записи по объявлению» (a828055)
• К2–К7 черновик: печать записи — строка квантора постусловия, блок свободного утверждения, «таких что», «допущение» теоремы, суффикс шага «допущение J», «свидетель»/«после подстановки»; старая форма forall (один узел) принимается (ff380a9)
• ведро Е, печать (черновик E-4, ADR-0027): блок «вывод» для разбора цели по условию — ГипО + Р5/Р6 | С4 | Кон3→О2 + Разв2 + Р1; по внутреннему условию — Выч×2 + Р3 + Разв2; по дизъюнкции в допущении — ГипД (+П2/Или1/Или2) ×2 + Р4 + Разв2; «Строки утверждения» зовут «Вывод записи по объявлению» (9b413c3)
• К3/К5/К7 в ядре: утверждения, допущения теоремы, свидетель (f914dea)
• К3 в принципе индукции: посылки свободного утверждения строятся из самой цели (e945047)
• К1 по списку: имя индукции обязано быть среди названных за «для всех» (40f5c01)
• задача 9980: модуль «TOML» — разбор названного подмножества без рекурсивного спуска (свёртка по строкам документа с накопленным путём таблиц): пары, заголовки [a] и [a.b] любой глубины, строки с экранами и литеральные, целое и вещественное различены синтаксисом, признаки, однострочные массивы скаляров, комментарии; каждая невзятая конструкция (inline table, [[имя]], дата, """, \u, точечный ключ) — отказ «Синтаксис вне подмножества» с номером строки, а не тихая порча; десять названных причин отказа; «Значение по пути», «Напечатать toml» и круг печать → разбор (7350433)
• задача 9978: модуль «WebSocket» — рукопожатие RFC 6455 из готовых деталей (разбор запроса http, SHA-1, Base64): «Ключ принятия» от ключа из §1.2 даёт ровно s3pPLMBiTxaQ9kYGzzhZRbK+xOo=, отказы названы порознь (нет Upgrade, нет Connection, нет ключа, запрос не разобран); кадр §5.2 списком октетов-чисел: три формы длины (до 125, 126 — два байта, 127 — восемь, шире 2^53 — «Кадр испорчен»), маска снимается исключающим или арифметикой по весам разрядов, «Собрать кадр» и круг разбора; векторы §5.7 (Hello с маской и без, фрагменты, ping) (760717f)
• К2 ведомость: forall списком — имена через « и », одно имя побайтно как прежде (42f2256)
• К2/К3/К5 типы: «Сверить квантор» по списку имён с хвостом решения 4; ограничение «таких что» — признак; свободное утверждение типизируется в области своих связанных, несвязанное имя — FLANG_PROOF_UNKNOWN_VAR (272674e)
• К2/К3/К5 обязательства: forall — список узлов параметров (пусто вместо ничто), hypotheses из «таких что», обязательство statement, теорема закрывает постусловие или утверждение (83d0ec4)
• ADR-0026 К2/К6 (сверщик): имена за «для всех» — списком; строка записи «для всех «а» «б» строка N» сличается знак в знак; переключатель строгого режима строк (23c1ff7)
• 6203 Ш2 (сверщик): строка «объявление» под принципом читается и сличается знак в знак с объявлением типа в исходнике (e4c2c1d)
• задача 9972: модуль «CLI» — разбор доводов командной строки по объявлению флагов для программ пользователя: «--имя значение» и «--имя=значение», «--» закрывает флаги, «--help»/«-h» — отдельный исход; каждый отказ — свой вариант (неизвестный флаг, пропущено значение, лишнее значение, флаг задан дважды, нет обязательного флага, позиционных не хватает, лишний довод); запасные значения подставлены незаданным; «Справка» вычисляется из того же объявления — добавленный флаг появляется в тексте сам (eae241b)
• К1/К8 черновик: квантор при теореме называет переменную индукции; индукция по функции — именованный отказ (a5f082f)
• проза при приметах догнала числа: оболочка 23308 строк; ведомость 171 строка, 84 правила (72 и 12), по ADR 67 и 5 (3c777d2)
• приметы пересняты после приёма ведра Е: строк *.sh 23308, оболочки 23908, C 797328, ведомости 171 (5182d8a)
• ведро Е, приём: Кон3 (конечность из факта «( Т минус Т ) равен 0») и посылка О2 «Т : кон»; ведомость — ГипО/ГипД/Выч/Или1/Или2, Р1–Р6 «код», Р7 «нет-в-коде», опора Р1 «Ветвлением», отпечаток переснят; С-2: правил из ADR 55 → 67; проба order-arithmetic и две подделки Кон3; храповик — ADR-0027 §3.5 (57dc804)
• Сверщик ужат на 51 строку кода без потери проверок: один разрезатель доводов вызова и один читатель строки «принимает» (b7b25de)
• ведро Е, пробы приёма: четыре golden-записи стека E в семье «вывод/р» и тринадцать подделок порчей строк в прогоне (состояние W-E3 на обрыве) (4812d29)
• Ловушка проверки 1: запись охраны правлена руками — пометка в ВИДЫ.tsv и README семьи; задача 6204 (узел со смешанными правилами посылок — в приём) (67d6d1e)
• ведро Е, добавка приёма: Выч (половина_закрыта переиспользована) и Р3/Р2 сличением половин (2e3efda)
• ведро Е, ядро приёма: имена гипотез ГипО (охрана, «сам») и ГипД (дизъюнкт, «строка N») — решение overagent (99345a2)
• задача 9975: модуль «UUID» — разбор 8-4-4-4-12 с тремя названными причинами отказа (длина, дефис, не шестнадцатеричный знак), печать строчными, версия и вариант арифметикой, v5 из пространства имён и имени через SHA-1 (векторы RFC 9562 A.4: DNS+www.example.com → 2ed6657d-e927-568b-95e1-2665a8aea6a2), v4 из шестнадцати октетов доводом с правкой битов версии и варианта даже на враждебном входе (e389bc6)
• К11+: ловушка — узел algebra с доменами «не больше» и «охрана» (видов 31→33); С-6 меряет строки КОДА, потолок = база 5788 + бюджеты ADR (6788) (1b50ad8)
• ведро Е, ядро приёма: Гип/Случай с учётом открытых гипотез, Р1/Р4/Р5/Р6, Или1/Или2, С4/П2 из шага (240af23)
• задача 9979: модуль «DNS» — разбор и сборка пакета RFC 1035 на «Wire»: заголовок, имя с метками и сжатием (прыжки только назад, предел витков — длина пакета; зацикленный и «вперёд» указатели отвергаются с названной причиной и местом), записи A/AAAA/CNAME/NS/MX/TXT и «данные как есть», «Собрать запрос»; круг запроса 33 октета RFC (cc65271)
• задача 9981: модуль «Protobuf» — формат провода без схемы: varint (300 → AC 02), тег (номер×8 плюс тип), fixed32/fixed64 младшим байтом вперёд, сообщение как список полей с сырыми байтами вложенных; значения ограничены отрезком [0, 2^53−1], сверх — названный отказ «Число шире 2^53»; круг 30-байтного сообщения байт в байт (595aea4)
• К12 черновик: словарь ru/en — «таких что»/such that, «есть такой»/there is, «а именно»/namely, statement (147b3e0)
• 6203-Ш1: имя примера без вложенных ёлочек (лексер не принимает « внутри имени) (2f0f37e)
• задача 9976: «Date and time» — «Длительность» (одно число секунд, канонична по построению), «Отметка из секунд» обратно к «Секунд от эпохи» (круг постусловием), «Прибавить длительность» с переходом через сутки и год, «Интервал» (полуоткрытый; «Содержит момент», «Пересекается»), дробные секунды отдельными функциями без правки «Разобрать отметку»; старые 53 утверждения — доказано 27 / сетка 26, число в число (ff6f700)
• К11: ловушка проверки 1 — по одной цели на каждый вид обязательства, 31 вид под храповиком (9f49c2c)
• 6203-Ш1/Ш2 черновик: принцип типа читается с объявления; запись печатает строку «объявление …» (fdc14f0)
• К9: храповик доверенной базы сверщика — потолок строк 9353 и примитивов 15 под сторожем С-6 (b8e12a3)
• задача 9977: модуль «Statistics» — среднее, медиана, мода, дисперсии по совокупности и по выборке (делители n и n−1 названы постусловиями), квантиль линейной интерполяцией, свой «Корень» Ньютоном за 48 витков точным шагом; NaN разоблачён через (x минус x) равен 0, потому что «равен» на не-числе истинен (ab05c97)
• задача 9974: модуль «Number format» — печать неотрицательного в основаниях 2…16 одной функцией, печать с заданной точностью (округление на масштабированном значении; 4.35 → 4.35, а не 4.34), круг с встроенной «к числу или беда»; отдельным файлом, потому что numbers.flang в замыкании семени (d164169)
• 6202-И3 черновик: обязательство входа и посылка Пред1 у П3 в блоке вывода записи (575edb3)
• задача 9973: регистр вверх для кириллицы и латиницы — «Точка вверх», «Знак вверх», «Вверх» в «Samples» зеркально «Точка вниз»; ё/Ё особняком; Strings не тронут (он в замыкании семени) (6326033)
• 6203 Ш0: носитель индукции читается с объявления типа — объявление_типа() в сверщике, один список имён отрезка под сторожем С-5, семья «носитель», набор 31→33 (fd56f8b)
• записи проб Ч56/Ч375/Ч7104 пересобраны честно: набор проб зелен, соундность цела (3901cd8)
• 6202 И2: тринадцатое семейство «Пред» в ведомости — П3 получает посылку ⟨1⟩ Т : предст, строка Пред1, сторож С-2 знает семейство, отпечаток переснят, леммы Lean (f3af393)
• записи корпуса догнали правленые исходники: пять перевыпущено (f7f2416)
• 6202 И1: П3 берёт посылку Пред1, обязательство входа читается и закрывается зовущим — доля 567/651 та же, подделка П3-без-посылки 0→1 (70b928c)
• О5 несостоятельно: конечность прибавки спрошена в перечне, в сверщике и пробой (729b297)
• задача 6201: доводы на снятые файлы JavaScript переписаны на живые источники, скрипты починены (8618701)
• чекер: блок вывода берёт семейства отношений — порядок, строгий, соседние, вхождение, начало (8c98c03)
• правила вывода сверены ядром Lean 4: из 78 подтверждено 75, отвергнуто 2 (2afa542)
• узел берёт развёртку по конструктору, выбор внутри терма и охрану-конъюнкцию: доля 561 → 567 из 651 (66a3251)
• приметы чисел в прозе догнали дерево: строк и примеров в flang/self, заметок в базе знаний (7dc6635)
• ядро печатает вывод факта о типе: 4 места из 35 и 2 из закрытых вычислением (12f5623)
• узел берёт допущение функции и обзавёлся пробами на подлог: доля 559 → 561 из 651 (9440408)
• тождество берёт свёртку пройденным куском и цель-выбор: доля 547 → 559 из 651 (63ab3ce)
• узел берёт цель-неравенство закрытым списком правил ядра: доля 533 → 547 из 651 (538dd54)
• переигрыш узла берёт свёртку, тождество и многострочную ветвь: доля 520 → 533 из 651 (490ac64)

Ещё 140 правок языка снаружи не меняют.

0.7.16 — 9 сентября 2026

чекер переигрывает вывод факта о типе; дорога до конца измерена

• выпуск 0.7.16: отпечаток архива снят разведочным прогоном ДО метки (63a624b)
• ведомость правил: семейство Р, семь законов разбора — те 25 мест, что решают порог (5d258df)
• выпуск 0.7.16: версия поднята, заметки на двух языках записаны (9bcc00a)
• корпус догнал перепечатанное ядро: доля 517 → 520 из 651 = 79,88 % (b1c0fd9)
• семя перепечатано из 52059e306: имя типа, пакет, печать Elixir, изоляция модулей, два печатника (c8c1727)
• отпечаток оболочки догнал исходник: 9f361fce (d697b26)
• линейка считает переигранный вывод числителем, а не снятым калькулятором (943ab9b)
• приём «вывод»: сверщик переигрывает записанный вывод факта о типе (7de8b17)
• внутренние слова убраны из читательских страниц: тринадцать мест переписаны словами (5e896e5)
• имя типа: остаток «нат» в позициях типа назван «неотрицательное» (8309) (0cc595e)
• печать Elixir: имя результата печатается один раз, а не на каждое постусловие (41a6e5f)
• изоляция: FLANG_MODULE_ROOT обрывает подъём поиска модуля выше названного корня (585c772)
• пакет: ведомость зовёт «Прогоны для ядра» двумя доводами, как объявлено (89c2dc9)
• запись: печатник цели-требования и вхождение по построению — три места уходят со слова ядра (d9a76aa)

Ещё 12 правок языка снаружи не меняют.

0.7.15 — 8 сентября 2026

калькулятор снят из чекера, гейт независимой проверки закрыт

• выпуск 0.7.15: отпечаток архива снят прогоном конвейера; расхождение сборок заведено задачей 4471 (14a4bde)
• выпуск 0.7.15: версия поднята, заметки записаны, кран и плагин догнали (04b2d1d)
• волна разбора цели: измерение оставлено, приём отведён (20ce87d)
• чекер: разбор цели по отрицаемому условию — три места corpus-hof сняты со слова ядра (1d96d3a)
• следы правки убраны за собой: примета строк, долг жаргона, опись (ca5e12b)
• контракт слоя доказательства: 162 мёртвых имени сняты (31a73d4)
• карта отказоустойчивости и контракт распределённости — по тому же правилу (364fb55)
• контракты слоёв core и conc называют сегодняшние файлы (05a0cf5)
• живые страницы перестали называть снятые файлы (763463f)
• refactor(дерево): снять все комментарии из ярлыков, сверщика, замера и гонки (5b7175e)
• refactor(examples): снять все комментарии из 4 ядер примеров-рамок (91ac5a1)
• оболочка(5498, 4316): отпечаток сборки в --version и то, что взято у iex (17ca108)
• учёт: находка про вхождение — в задачу 6133, опись и приметы поправлены (f98d195)
• восемь проб на подлог: каждый из четырёх сторожей показан краснеющим (f34a0b8)
• четыре сторожа над ведомостью правил вывода (662cb38)
• ведомость правил вывода: 71 строка в двух нотациях, сверенная с ядром (d25b0fb)
• учёт ADR-0023: состояние «исполнено», перемеренные числа, заметка, приметы (9877309)
• Ш5 ADR-0023 (половина): регэксп по имени файла снят с линейки (d3eebd7)
• опись 3781: приметы пересняты, номер задачи выправлен по имени файла (52bf074)
• Ш3 ADR-0023: из знаменателя доли вынесены недостижимые места (dce3ab0)
• Ш2 ADR-0023: прогон проб берёт класс из манифеста, а не из имени файла (10eae37)
• Ш1 ADR-0023: набор подделок заведён манифестом, а не приставкой в имени (a38cf12)
• 9982: вычислительная часть снята и во второй её точке — двери 5 «половина_закрыта» (54898bc)
• 9982: сторож ложной переписки отделён от прувера, прувер счётом удалён (db14e81)
• 1573: пробы на каждый новый род счёта — честная и подделка (f977a9e)
• 1573: вычислитель чекера считает то, что раньше брал на слово (6b7d8e0)
• seed: перепечатка bootstrap с печатниками ходов — тождество после переписки (18 мест) и разбор цели (33 места) (17548d8)
• опись: пол-доказанного zapis.flang после печатника разбора (написано 138→153, доказано 85→96, сетка 51→55, md5), приметы flang/self (примеров 4668, строк 131 543), итог задачи 5763 и поправка в заметку (4cc7a2f)
• корпус: шестнадцать записей перепечатаны с печатником разбора цели — 33 места проигрываются ходами (c26b24f)
• запись: планировщик разбора молчит на теле со свёрткой, разбором или отображением (5dfce08)
• сверщик: довод индукции с дном узнаётся под обоими именами типа (8309) (60b3e2d)
• слово наружу: страницы, курс, навыки и оснастка говорят «неотрицательное» (8309) (a6b735c)
• примеры и спеки: «нат» → «неотрицательное» в позициях типа (8309) (47ed248)
• пробы и корпус доказательств: исходники на «неотрицательное», записи перепечатаны (8309) (b13fc1e)
• библиотека и слой согласования: «нат» → «неотрицательное» в позициях типа (8309) (b256d2d)
• семя: тип «нат» в позициях типа назван «неотрицательное» (8309) (7efdc5b)
• запись: печатник «разбор цели по условию» — 33 места получают цепочку ходов по контракту сверщика (f8284ef)
• десятая цель печати в документах, описях и приметах (24b94f6)
• регистрация цели ts и проба печати из исходника, минуя семя (ea8fdb5)
• печать в TypeScript: тот же генератор, что у JavaScript, с признаком «типизировано» (c6c88f5)
• stdlib: сняты все комментарии из 4 файлов семени (hashmap, numbers, strings, tree) (dae5ae1)
• task(задачник): пять пятизначных номеров возвращены в полосу 1000…9999 (91abe36)
• доля-корпуса.sh: зеркало пород не кладёт в П1 места, проигранные ходами под постусловием; проба П10 — запись нынешней формы (4be93a5)
• опись: задача 10006 (перенумерована с 10004, итог прогоном), приметы строк flang/self и заметок базы знаний после слияния gh/dev (501ad32)
• корпус: шесть записей перепечатаны толкователем с правленой печатью — 18 мест perepiskoy проигрываются ходами (625a9b4)
• flang/: спека самоприменения переписана по коду, README библиотеки и улик — указатели (632aa0f)
• README редакторов: flang-lsp и linguist — указатели, vscode — строгий текст для Marketplace (37b2f41)
• README примеров: семь каталогов — указатели по образцу editors/README.md (23f9dbf)
• packaging: сабмодуль asdf-plugin на синхронизированный коммит asdf-flang (1785256)
• пробы сверщика: семья «разбор цели» — честная запись на семь видов ходов, ложь под каждый, восемь порч строки, проба вакуума (6127) (d299e9c)
• сверщик и линейка: вакуумный успех узла algebra не засчитывается; булева ветка — отдельным полем сводки (6127) (482c906)
• сверщик: разбор цели проигрывается ходами — Б2* (условие в скобках у деления) и Б3 (семь локальных видов) (6127) (bea4ba7)
• docs: README плагина asdf — указатель в docs/, страница установки сверена с bin/install (99b13f1)
• feat(packaging): плагин asdf — сабмодуль packaging/asdf-plugin и сторож «плагин:проверка» (341a8ca)
• запись: цепочка переписки знает Э1–Э4 и счёт длины строкового литерала (bb286da)
• запись: печатник С2 закрывает тождеством только тождественные стороны — цель считается нормализацией сверщика (26e30b8)
• оболочка(3636): редактор строки, история и тема digitable в flang repl (394b260)
• refactor(stdlib): снять все комментарии из 38 файлов stdlib по решению владельца (588e190)
• доки и пробы сверщика: имена приёмов чекера в кириллице вслед за сверщик.c; приметы (77c521a)
• сверщик: идентификаторы переведены с транслита на кириллицу, гейт Г7 грепает перепиской( (da09a98)
• ct: пять популярных категорий на настоящих задачах — Set, Vect, Grp, Pos, Mon⇄Set (3197) (fb802e6)
• линейка Г4: структурный переигрыш узлов тотальности — отдельная строка числителя (+34, 60,78→66,29%) (4aae0f0)
• feat(packaging): кран Homebrew — сабмодуль packaging/homebrew-tap, и выпуск не может его забыть (71c40ca)
• refactor(packaging): снять все комментарии из формулы Homebrew по решению владельца (2e7cc99)
• refactor(packaging): снять все комментарии из install-check по решению владельца (768ddb0)
• refactor(packaging): снять все комментарии из install-parity по решению владельца (6732577)
• refactor(packaging): вычистить install-parity — дубли в подфункции, мёртвая ссылка (ec32e4c)
• feat(чекер): проигрыш узла «разбором по случаям» с БУЛЕВОЙ целью случая (f2e6de7)
• feat(чекер): проигрыш узла «разбором по случаям» с ветвью-случаем — скобкой если(У)то (97b3b7f)

Ещё 124 правки языка снаружи не меняют.

0.7.14 — 7 сентября 2026

доля корпуса независимым чекером 5%→60,78%

• release(0.7.14): sha256 архива в формулу Homebrew (2833cad)
• release(0.7.14): версия и семя 0.7.13→0.7.14, release notes (3ce22f0)
• линейка Г4: числитель кредитует проверенное ПО СУЩЕСТВУ («по примеру»/«по свойству») (f5ca9e8)
• seed: перепечатка bootstrap с выпуском узлов тотальности РЕКУРСИИ (d1bbbf9)
• feat(ядро): выпуск узла тотальности РЕКУРСИИ — виды structure/step с полным свидетелем (5d73d39)
• feat(запись): печать блока тотальности рекурсии — виды structure/step (9621236)
• feat(сверщик): переигрыватель тотальности РЕКУРСИИ — виды structure/step (4bfbd21)
• fix(пробы): корпус-подделки poddelka-svyortka-* — класс P (КОД 1 верен), восстановить «сошлось всё» (312b4e2)
• feat(сверщик): межмодульная линковка тотальности — путь (1), многозаписьное замыкание (f0d6600)
• chore(корпус): регенерация 82 записей со следом тотальности-композиции ([Ш3]) (fba02c9)
• fix(тотальность): переигрыш сертификата НЕЗАВИСИМ ОТ ПОРЯДКА блоков [Ш3] (6421580)
• fix(доля): [Ш5] честный знаменатель доли-проигрыванием — ни одна запись не выпадает (10beaf7)
• chore(семя): перепечатка семени со следом тотальности-композиции ([Ш3]) (33096c2)
• refactor(ct): теория категорий — переименование, README, реализации, спека в docs (acca80a)
• feat(обязательства): [Ш3] выпуск узлов "totality" для функций-композиций (3ed67fe)
• feat(запись): [Ш3] печать секции сертификата тотальности-композиции (zapis.flang) (de070f7)
• feat(чекер): [Ш3] переигрыватель сертификата тотальности-композиции (0f296f4)
• feat(доля): прибор доли-проигрыванием — режим --проигрыванием (Ш5) (00a56ba)
• refactor(examples): убрать комментарии и дубли (1208008)

Ещё 9 правок языка снаружи не меняют.

0.7.13 — 6 сентября 2026

• release(0.7.13): sha256 архива в формулу Homebrew (29fe775)
• release(0.7.13): версия и семя 0.7.12→0.7.13, release notes (b6675c2)
• chore(семя): перепечатка семени со следом доказательства (4125) (c3d1718)
• refactor(проверки): убрать комментарии, дубли, translit-имена (3e4793c)
• feat(чекер): S2 — неравенства и нетекстовая оплата требует (c0da0cf)
• feat(печать): весь след доказательства (вычислительный + леммовый) в семя (2eb5633)
• fix(чекер): дожать S2 — оплата требует, захват имени, круг ур.2 (d433f3b)
• feat(чекер): приём S2 «постусловие вызванной» — независимая проверка лемм «по свойству» (e5a7536)
• test(доказательство): золотые сертификаты семей С3/С4/С5 (78d964c)
• fix(чекер): гейт принципа + нормализация скобок (3cb04bc)
• feat(чекер): ход «переписать формой» — законы Э1–Э4 (семья С4 «Элемент») (b0ef3a3)
• seed(6754): перепечатка семени под sha256 (ee3b012)
• feat(чекер): ход «переписать формой» (Д1–Д5) для С3 «Длина» (269d3cc)
• test(доказательство): 4104 — рукотворные сертификаты следа семей С1/С2 (834c359)
• feat(чекер): ход «вычислить» (P8) для С5 — замкнутый счёт в переигрывателе (a1f19f2)
• feat(examples): три примера flang под JS-фреймворками (374e9aa)
• fix(чекер): 4102 — переигрыватель гейтит равенства-постусловия по наличию цепочки ходов (3931ae1)
• merge(ядро-доверия): волна 1 — Г4 49 в 53 из 86, чекер и линейка честнее (95926eb)
• fix(линейка): зеркало пород поехало за чекером + сторож пустого числителя (67afc91)
• chore(опись): три пробные программы Ч7104 внесены в опись обязательств (932e596)
• fix(чекер): ложный ход больше не снимает долг там, где ходы никто не проигрывает (8241a9a)
• feat(чекер): segment Р2 → Р0 — пустое правило посылки и ветвь «если» (замер 7105) (8477fb7)
• feat(чекер): произведение в спуске + заслон на стёртое имя правила (замер 7107) (01fa941)
• fix(чекер): закрыт рецепт накрутки доли Г4 через «по предположению» (a31814f)
• fix(линейка): числитель Г4 считал пустые записи и не видел снятого вердикта (a6d1571)
• fix(чекер): мера значения — не само значение; заслон и подделка на него (5e931fe)
• build(семя): перепечатка ступени Б — ключ кеша считает встроенное слово (262509e)
• proof(чекер): дыра «ходы без теоремы прячут долг» названа числом (e011e70)
• fix(чекер): места «на слово ядра» больше не растут молча — названы все (18fb9e6)
• feat(чекер): три приёма шага «по примеру» — вложенная свёртка, нулевой знак, вызов соседки по случаю (f588440)
• fix(печать): emit говорит, если тулчейна для сборки напечатанного нет (81537a5)
• perf(6754): главный замер снят на настоящем ядре — оба слоя ключа, 7,8 раза (749f61c)
• docs(6754): цена перемерена в трёх местах, сторожа зелены (d4037cf)
• feat(язык): sha256 стал встроенным словом «хеш256» — девять печатей, кеш приговоров окупается снова (5c90d6f)
• release(0.7.12): формула указывает на опубликованный архив (f18ebea)
• feat(печать): исполнитель плана цели python лёг в дерево (e84e290)
• feat(печать): у цели js появился хозяин Node — 9 родов из 22, остальным внятный отказ (7e7007a)
• feat(сторожа): перечень команд сверяется по пяти местам; man и оба README не знали «new» (fb29de4)
• fix(упаковка): пробы установки щупают девять целей вместо одной-двух (e92984c)

Ещё 53 правки языка снаружи не меняют.

0.7.12 — 6 сентября 2026

Выпуск, который наконец отдаёт людям все девять целей печати.

0.7.11 вёз рантайм ОДНОЙ цели: brew install ставил share/flang/c и только, а восемь остальных были обещаны в man, в обоих README и в справке самого двоичного — и у поставившего не работали. Нашёл это владелец на своей машине, попробовав flang emit --target js. Теперь архив, формула и asdf везут все девять, 32 файла, и проба формулы щупает две цели вместо одной.

Что ещё въехало от 0.7.11:

КЛЮЧ КЕША ПРИГОВОРОВ БЫЛ ПОДДЕЛЫВАЕМ. Многочленный отпечаток линеен — столкновение не искали перебором, а решали уравнением за 3,6 секунды. На живой программе: два постусловия, одно ядро доказывает, другое отвергает, имена подобраны под общий ключ — и печать с горячим кешем ставит НОЛЬ сторожей постусловия вместо одного, обоими кодами 0 и без слова в stderr. Ключ переведён на sha256. Цена названа честно: честный кеш не окупается, 23,0 с против 22,2 с вообще без кеша, потому что sha256 написан на flang.

ЦЕЛЕЙ В CI СТАЛО ВОСЕМЬ ИЗ ДЕВЯТИ вместо двух — расширение упиралось не в цену, а в то, что никто не мерил: шесть тулчейнов из семи уже в образе. Без присмотра осталась одна, elixir, и это сказано в выводе самого шага.

ЧЕКЕР ПЕРЕСТАЛ ВРАТЬ В ОБЕ СТОРОНЫ. Доля проверенного корпуса 32,56 % → 56,98 % по записям. Набор проб: 159 подделок, принято кодом 0 — ноль; 119 честных, отвергнуто — ноль.

ПРИМЕРЫ САМОГО КОМПИЛЯТОРА ГОНЯЮТСЯ. Их 4453, и до этого выпуска не исполнялся ни один; теперь под присмотром 4350.

СЕМЯ ВОСПРОИЗВОДИМО: две перепечатки одного дерева дали побайтово одинаковое тело — 4 файла, 1 229 825 байт.

Порода, всплывшая за сутки восемнадцать раз и стоящая тут отдельной строкой: сторожат ровно то, что умеют посчитать.

• release(0.7.12): семя перепечатано, двоичный говорит 0.7.12 (d4bede1)
• Ч388: линия flang снимает привязку «пример строка» и честно метит такие шаги на слово ядра (f6b7a13)
• feat(сверщик): минимальный вариант свёртки для шага «по примеру» вне случая (8690-V4) (9285413)
• fix(сверщик): сужаю по объявлению — место платит один раз, не два (1816258)
• fix(сверщик): подстрока и chleny_spiska — байтовый скачок за кириллицей и экранированная кавычка (d9b04fa)
• fix(сверщик): значение «по объявлению да|нет» встаёт на слово ядра (1e3a839)
• fix(сверщик): V2 - tablica_spiskom принимает список в одну строку (a74007f)
• fix(сверщик): R6b — dano_primera узнаёт довод и в ёлочках, не только голым словом (65decaa)
• test(чекер): пробы на носитель algebra узла «разбором по случаям» (bb1e15a)
• feat(чекер): второй носитель приёма «разбором по случаям» — algebra (e11ed93)
• test(чекер): пять проб Ч71 позваны прогон.sh, а не просто лежат в дереве (24cee17)
• feat(чекер): невыполнимая посылка — из несовместимых допущений следует что угодно — Г4 33,72 % → 34,88 % (3e2ac46)
• feat(чекер): начало по построению — значением, не только тождеством — Г4 32,56 % → 33,72 % (2d58f99)
• fix(запись): шаг «по свойству» получил привязку к постусловию (3455) (deb1a7c)
• test(чекер): пять проб на Ч71 закрывают слепоту проверок 2/3/4/5/6 (8a63a0f)
• fix(линейка Г4): П3 сличается с чекером за вычетом шагов, проверенных по существу (fc95369)
• chore(корпус): 67 записей перепечатаны нынешним двоичным (e1e362d)
• feat(сторожа): девятая цель печати дописана пяти слепым сторожам — и нашла, что «cpp» экранирует имена по списку «c» (9fb0f29)
• feat(доля-корпуса): приговор ядра — ядро судит сам файл, названный записью дерева (f31fb32)
• chore(версия): 0.7.11 → 0.7.12 (cd504be)
• fix(кеш): цена честного ключа перемерена на том, что легло в дерево — кеш перестаёт окупаться (70b53ac)
• fix(ядро): ключ кеша приговоров считается sha256 — 59,79 бита многочлена подделаны за 3,6 с (deea0d6)
• fix(packaging): выпуск везёт рантаймы всех девяти целей, а не одной (1129587)
• fix(proofterm): «Это число» дописано в список ввоза — 1289 примеров не шли никогда (a85c7bb)
• test(чекер): щель остатка 2718 померена по всему дереву — 23 места в 7 записях; заведена проба-близнец, цена починки названа (a2467d5)
• feat(кеш-приговоров): печать называет попадания и промахи числом (c137e8d)
• fix(чекер): дыра 9984 закрыта обеими половинами — «закрыта reduction» сверяется с исходником, пустой «ход конец» не прячет долг (817be78)
• fix(доля-корпуса): дело чекеру называет дерево, а не проверяемая запись (395fbe8)

Ещё 33 правки языка снаружи не меняют.

0.7.11 — 5 сентября 2026

Семя перепечатано целиком (16 404 с, ПЕЧАТЬ КОД=0) и проверено четырьмя прогонами: семя = источник, раскрутка сошлась с отпечатком, двоичный говорит 0.7.11, страница руководства держит эту версию в четырёх местах сразу.

Что въехало за 34 коммита от 0.7.10:

ЦЕЛЕЙ ПЕЧАТИ ДЕВЯТЬ, не восемь. C++ печатала и собиралась начисто, а проза и сторожа держали восьмёрку. Исправлено в man, обоих README и курсе; сторож обещаний о печати научен считать девять и тут же нашёл второе расхождение, которого не видел никто: файл сборки печатают восемь целей, а обещали семь. Названо прямо и то, что хуже: девятую цель не сверяет с вычислителем никто.

ЧЕКЕР ПЕРЕСТАЛ КРИЧАТЬ НА ЧЕСТНЫХ. Объявление типа читалось сквозь примечание: 62 ложные тревоги из 923 на честных записях честных программ — теперь ноль. Цена — две строки кода. Подделок 138, принято кодом 0 ноль.

СТОРОЖА, КОТОРЫЕ НЕ МОГЛИ ПОКРАСНЕТЬ. Один возвращал «провал» в обеих ветвях, отчего шаг был зелен при любом исходе. Второй молчал оттого, что запись «отсрочка» глушила имя во всём дереве. Семи сторожам заведены пробы порчи; показанных прогоном стало 15 из 59 вместо 8.

ОПИСЬ ДЕРЕВА СВЕРЯЕТ СВОЮ ЖЕ ТАБЛИЦУ и научилась считать то, что не считала: правило врало в НЕДОСЧЁТ на восемь файлов. Разрыв долга с потолком был не 41, а 49; сегодня 43. Потолок не тронут.

ЦЕНА ПРИМЕРА ПОМЕРЕНА ПОШТУЧНО и опровергла оценку в 46,3 часа: выходит 11–25, из них 5,5 померены. Причина дороговизны — глубина вычисления, а не длина тела: в языке нет побитовых действий.

Порода, всплывшая за сутки одиннадцать раз и стоящая тут отдельной строкой: сторожат ровно то, что умеют посчитать.

• release(0.7.11): семя перепечатано, двоичный говорит 0.7.11 (6e12ee1)
• fix(чекер): объявление типа читалось сквозь примечание — закрыт ложный приём и пять ложных тревог (a54d4b5)
• docs(цели): их девять, а не восемь — и девятую никто не сверяет (0dba1bc)
• task(8935): десять примеров семи функциям блока кеша, и примеры self не гоняет никто по-файлово (fad0e8a)
• release(0.7.11): версия поднята в ИСТОЧНИКЕ — семя ждёт перепечатки (a2b42d4)
• perf(proofterm): не спускаться внутрь места, которое всё равно выбрасывается — минус треть обхода (6804858)
• fix(proofterm): отбор переехал после отображения — спуск снова виден ядру, перепечатка разблокирована (fedc79e)
• fix(лицензии): три прибора привязки внесены без SPDX — сторож нашёл, когда CI наконец пошёл по dev (6917c16)
• fix(запись): путь в шапке — относительный, и корпус снова можно перепечатать (ef14bef)
• fix(чекер): узел вердикта проигрывается и под теоремой — написанная теорема больше не роняет долю (f6ffd19)
• feat(Г5): прибор кругооборота внесён в дерево — число было невоспроизводимо из репозитория (c48a908)
• fix(ведомость): дорога --proof больше не выдаёт нуля тому, что check отвергает — задача 9712 (854696d)
• task(9518): доводы снятия Г2 перемерены — три сняты, дыра 9984 жива и глубже записанного (22a84e1)
• feat(чекер): правило «цель следует из объявленного о доводах» встало в дерево — Г4 12.08 % → 13.75 % (f5d378a)
• feat(чекер): правило «цель следует из объявленного о доводах» — под ключ, 12.08 % → 13.75 % (cc1f154)
• fix(сверщик): довод индукции берётся ДО двоеточия — закрыта последняя названная дыра Г2 (002b20f)
• task(9616): чекер научен ЧИТАТЬ «по объявлению» — доля не выросла, и это правильный исход (1200716)
• task(5209,6025): два красных сторожа починены; и найден ложный приём В ПЕЧАТИ, не в чекере (75ffd07)
• task(4970): пять версий расходились не от отставания dev, а оттого что выпуск делается на main и назад не возвращается (f1c3672)
• task(5397): «пяти законов» нет — есть три правила ядра, и все три имени чекеру уже известны (645f39d)
• fix(сверщик): оговорка о конечности берётся в посылку — Г4 11,25 % → 12,08 %; и найдена третья слепота проб (ee23dd7)
• fix(сверщик): отрицание замкнутого счёта — Г4 впервые сдвинулся, 7,50 % → 11,25 % (25181b1)
• task(10004): целей девять, а 56 перечней в дереве говорят «восемь» (569dfa9)
• fix(сверщик): оба ложных отказа на свежей печати закрыты, и снята мина перепечатки (7c73aa2)
• task(4707): ast не говорит, из какого файла функция — правка 13-17 строк в одном файле; и прибор Г5 положен в дерево (235c196)
• task(10001): форма «результат равен» — это 2 места, а не 15; и второй вычислитель для них НЕ нужен (0f7226f)
• task(9998): правило «начало по построению» готово под ключ — и доказало, что Г4 устроен «всё или ничего» (8d6f510)
• fix(сверщик): вид посылки судится и на носителе algebra — по объявлению типа; и обе пробы вида наконец гоняются (7443fed)
• fix(сверщик): вид посылки не спорит с именем ядра — закрыт ложный приём на СЕРТИФИЦИРОВАННОЙ записи (2678b78)
• task(9992): пробы под щели 9984/9986, и главное — механизм проб слеп к тихому зачёту (683cdb7)
• fix(proofterm): strip span recursively from verdict-cache key, not just top-level (d621bda)
• docs(release): document the homebrew-tap sync step — missed for six releases (7e1dec6)
• chore(bootstrap): семя обновлено перепечаткой с 3 сентября 04:06 (22d54485) (659d477)
• feat(zapis): печатать правило и byType для вердикта «по объявлению» (9616) (818a2a7)

Ещё 132 правки языка снаружи не меняют.

0.7.10 — 4 сентября 2026

Шесть тегов подряд (v0.7.4-v0.7.9) не дошли до публикации, гоняясь за sha256 Homebrew-формулы вручную, каждый раз ловя её несовпадение с тем, что собрал сам конвейер выпуска. Настоящая причина нашлась только на седьмой попытке: у release.yml workflow_dispatch никуда не делся — снят был только у СТАРОГО publish-npm.yml (задача 8649 про npm его не трогала). Сухой прогон на main даёт настоящий хеш архива БЕЗ метки — шаг сверки тега с версией гейтится refs/tags/v и на ручном пуске не звучит. Ни разу за все шесть попыток ничего битого не вышло: конвейер сам останавливался до публикации. Ни один тег не удалён, все просто пропущены.

Хотфикс: REPL падал на КАЖДОМ вводе живой оболочки (FLANG_UNKNOWN_NAME: запись не содержит поле «планировщик заголовок») — ручной список полей в flang_repl.c отстал от таблицы EMIT_FIELDS_C на два поля. Фикс landed на dev 3 сентября (Ч390, 8e02c37e), но после тега v0.7.3.

Заодно: FLANG_VERSION в семени отставала на три релиза; задача 9983 заведена, чтобы это не повторялось. Проверено живым REPL через настоящий псевдотерминал.

main получил дневную работу dev целиком — задачи 9960 (12 ячеек Node→flang), 9982 (SIG9 у спаунутого check), первая сошедшаяся пара two-prints-identical.sh, находка и починка второй дыры в независимом чекере (Г2).

• release(0.7.10): реальный sha256 (сухой прогон), release-notes, честная история формулы (35f4c9d)
• release(0.7.10): версия 0.7.10, формула — плейсхолдер до сухого прогона (799ece3)

0.7.9 — 4 сентября 2026

намеренная метка для сбора настоящего sha256 у конвейера (см. следующий тег за реальным содержанием)

• release(0.7.9): версия, формула (нарочно на провал), release-notes — v0.7.8 тоже пропущена (7d512aa)

0.7.8 — 4 сентября 2026

намеренная метка для сбора настоящего sha256 у конвейера (см. следующий тег за реальным содержанием)

• release(0.7.8): версия, формула (нарочно на провал), release-notes — v0.7.7 тоже пропущена (b3455c4)

0.7.7 — 4 сентября 2026

намеренная метка для сбора настоящего sha256 у конвейера (см. v0.7.8 за реальным содержанием)

• release(0.7.7): версия, формула (нарочно на провал), release-notes — v0.7.6 тоже не дошла (d338b41)

0.7.6 — 4 сентября 2026

v0.7.4 и v0.7.5 не дошли до публикации: конвейер выпуска сверяет sha256 Homebrew-формулы с архивом, который сам собрал на теге, и оба раза остановился ДО публикации на несовпадении (0.7.4 — формула ещё несла хеш 0.7.3; 0.7.5 — локально пересчитанный хеш всё равно не совпал побайтово, причина не разобрана). Оба сработали как задумано: ничего битого не вышло, оба тега не удалены, просто пропущены — как v0.7.1 и v0.7.2 раньше. Хеш для 0.7.6 взят прямо из текста ошибки конвейера.

Хотфикс: REPL падал на КАЖДОМ вводе живой оболочки (FLANG_UNKNOWN_NAME: запись не содержит поле «планировщик заголовок») — ручной список полей в flang_repl.c отстал от таблицы EMIT_FIELDS_C на два поля. Фикс landed на dev 3 сентября (Ч390, 8e02c37e), но после тега v0.7.3.

Заодно: FLANG_VERSION в семени отставала на три релиза; задача 9983 заведена, чтобы это не повторялось. Проверено живым REPL через настоящий псевдотерминал.

main получил дневную работу dev целиком — задачи 9960 (12 ячеек Node→flang), 9982 (SIG9 у спаунутого check), первая сошедшаяся пара two-prints-identical.sh, находка и починка второй дыры в независимом чекере (Г2).

• release(0.7.6): версия, формула и release-notes — v0.7.5 тоже не дошла (db509ac)

0.7.5 — 4 сентября 2026

v0.7.4 не дошла до публикации: sha256 в Homebrew-формуле стоял от 0.7.3, конвейер выпуска сверил его с архивом, который сам собрал на теге, и остановился ДО публикации — сработал как задуман, ничего битого не вышло (workflow_dispatch dry-run для сверки заранее больше не существует с 3 сентября, задача 8649). Тег v0.7.4 не удалён, просто пропущен.

Хотфикс: REPL падал на КАЖДОМ вводе живой оболочки (FLANG_UNKNOWN_NAME: запись не содержит поле «планировщик заголовок») — ручной список полей в flang_repl.c отстал от таблицы EMIT_FIELDS_C на два поля. Фикс landed на dev 3 сентября (Ч390, 8e02c37e), но после тега v0.7.3.

Заодно: FLANG_VERSION в семени отставала на три релиза; задача 9983 заведена, чтобы это не повторялось. Проверено живым REPL через настоящий псевдотерминал.

main получил дневную работу dev целиком — задачи 9960 (12 ячеек Node→flang), 9982 (SIG9 у спаунутого check), первая сошедшаяся пара two-prints-identical.sh, находка и починка второй дыры в независимом чекере (Г2).

• release(0.7.5): версия и sha256 формулы — v0.7.4 остановлена конвейером до публикации (81145de)

Ещё 2 правки языка снаружи не меняют.

0.7.4 — 4 сентября 2026

Хотфикс: REPL падал на КАЖДОМ вводе живой оболочки (FLANG_UNKNOWN_NAME: запись не содержит поле «планировщик заголовок») — ручной список полей в flang_repl.c отстал от таблицы EMIT_FIELDS_C на два поля. Фикс существовал на dev с 3 сентября (Ч390, 8e02c37e), но приземлился ПОСЛЕ тега v0.7.3.

Заодно: FLANG_VERSION в семени была "0.7.0"/"0.6.2" — три релиза позади (та же болезнь, что чинил хотфикс 9959; заведена задача 9983, чтобы не повторялось). Проверено живым REPL через настоящий псевдотерминал.

main получил дневную работу dev целиком (164 коммита) — задачи 9960 (12 ячеек Node→flang), 9982 (диагностика SIG9 у спаунутого check), реальный шаг к Г6 (первая сошедшаяся пара two-prints-identical.sh), находка и починка второй дыры в независимом чекере (Г2).

• Homebrew: версия/URL 0.7.4; sha256 заведомо старый (0.7.3), правится после публикации (0675837)
• flang 0.7.4: FLANG_VERSION бампнута (была 0.7.0/0.6.2 в семени, три релиза позади) (6e8512b)
• Г2: найдена и пробой доказана настоящая дыра в двух из шести «непроверенных» мест (9964) (d583157)
• benchmarks/proof-cost/count-library.flang, flang/conc/bench/gen.flang: перенос двух из трёх (9960) (b05baab)
• Семя bootstrap/ обновлено перепечаткой с 30 августа (c15f669f) на 3 сентября (4312a476) (f692bab)
• 9969: _DARWIN_C_SOURCE в flang_runtime.c и flang_conc.c — тот же разрыв, второй раз (638a085)
• Добавлена команда flang new <имя>: старт пакета одной командой (9961) (ada8bda)
• fix(чекер): читать источник как язык ещё в восьми местах — Г2 шаг 2 (9964) (8d5a433)
• Ч393: пробы Ч369 без комментариев, приметы дерева догнаны на моей ветке (e313552)
• Ч369: проба порчей на приём разбора — надзорный и восемь мутантов (191b7b7)
• Ч369: чекер проигрывает узел «разбор цели по условию» (c0101a9)
• Ч391: перенос кеша приговоров Ч352 (v0.6.2/стенд) на dev — механизм (ea369cc)
• Ч388: добавлены примеры двух защитных веток «Сверить термин шага без номера» (0d63ca8)
• Ч388: сверщик на flang сверяет термин шага без номера с обоснованием (9612) (2dfe771)
• Ч390: живая REPL-сессия — repl_compile недодавал 2 поля записи «Настройки» (8e02c37)
• Надзор на js: опознавать конструктор тождеством полей, а не арностью (442377a)
• Ч375: третья ветка в чекере — термин сверяется с исходником, а не заменяет номер (9612) (f872afd)
• Столкновение имён: «Пара имён» переименована в «Соответствие имён» (c574f90)
• Ч370: версия 0.6.2 → 0.7.0 на dev — четыре места отставали от тега (6910460)
• Разбор альфа-инвариантности перенесён в задачу 9958, храповик поднят точно (ad6f4d8)
• Ч372: снять «тотальная» с семьи сличения и завести отдельное правило 11 (be64c5b)
• Ч372: альфа-инвариантное сличение целей с допущением и с телом (9958) (a8ca445)
• убрать npm: публикации нет, и Windows остаётся без пути установки (5d876b0)
• Ч366: отпечаток в записях корпуса — Г4 сдвинулся с нуля (4312a47)
• perf(печать): обход дерева вынесен из двойного цикла — печать втрое короче, вывод тот же (ebb722c)
• Догнать числа прозы и поднять храповик за пробные файлы — осознанно (4acce82)
• Мутанты приёмов Ч363 и Ч365 внесены в пробы дерева (2f66999)
• Ч365: чекер проигрывает узел «тождество после переписки допущением» (966d420)
• Заплата к линейке доли: учесть места, снятые проигрышем узла (18ea10f)
• feat(чекер): проигрывать узел вердикта «разбором по случаям» по отрезку (2578057)
• fix(check --proof): приговор ведомости доезжает до кода выхода (6f7412d)
• Ядро: спрашивать канон о связывателях, а не держать свой список (64dc455)
• Вернуть строку объявления записи «Сбор при разборе» (f4b511b)
• feat(разбор): порядок объявлений едет в дереве пятой корзиной (da1f402)
• chore(чистка): храповик опущен после чистки библиотеки и примеров (b3ebe88)
• чистка(examples): журнал вынесен из комментариев, кода не тронуто (88af1ec)
• feat(разбор): порядок объявлений едет в дереве пятой корзиной (843323f)
• чистка(stdlib): журнал вынесен из комментариев, кода не тронуто (49ae5fb)
• fix(приметы): адреса «СНЯТО» перепривязаны после чистки и терма (ec2431d)
• refactor(self,core): вынести журнал из комментариев остатка корпуса (8444dd3)
• feat(язык): терм «примечание» — объяснение причины попадает в дерево разбора (3101cf5)
• docs(язык): примечание в спецификации, словаре и подсветке двух редакторов (5eb4831)
• feat(язык): терм «примечание» — причина термом, а не комментарием (13059f7)
• chore(словарь, законы): за вынесенным журналом подобраны два заголовка (2f364d7)
• chore(связывание, словарь, законы, запись, понижение): журнал вынесен ещё из шести (4a7a026)
• chore(планировщик, отказы, лексер): журнал вынесен из трёх исходников (a457467)
• chore(ограниченность): журнал вынесен из исходника, объяснение поведения оставлено (6f1c028)

Ещё 103 правки языка снаружи не меняют.

0.7.3 — 3 сентября 2026

хотфикс версии довыпущен: sha256 взят у самого конвейера

Метки v0.7.1 и v0.7.2 не дошли до публикации: у обеих ручная сборка архива для Homebrew не совпала с тем, что собрал сам конвейер выпуска на теге (0.7.1 — расхождение полное; 0.7.2 — 4 байта из 4 447 763, причина не разобрана). Оба тега не удалялись (запись запрещена), просто пропущены. На этот раз число в формуле взято напрямую из sha256sum самого конвейера (сухой прогон release.yml через workflow_dispatch на этом дереве до метки), не пересчитано вручную.

Содержательно всё то же, что должно было быть в 0.7.1:

ЧТО СЛОМАЛОСЬ. FLANG_VERSION был вшит буквально в двух местах (flang/src/emit/c/flang_repl.c, bootstrap/flang_repl.c) и не менялся при бампе версии в package.json — двоичный 0.7.0 на flang --version отвечал «0.6.2», на два релиза позади. Через brew ставился пакет «0.7.0», а сам двоичный называл себя старым именем (задача 9959).

ЧТО ПОЧИНЕНО. Обе константы → 0.7.3. Формула Homebrew несёт sha256 этой метки; тап digitable-lol/homebrew-tap обновляется тем же приёмом следом за публикацией.

СВЕРХ ХОТФИКСА, тем же диапазоном коммитов: живая REPL-сессия падала на КАЖДОЙ введённой строке (запись «Настройки» несла 15 полей вместо 17, которых требует печать цели «c» с тех пор, как выучилась печатать процессы) — починено; надзор на цели js в dev получил фикс, найденный утром на main, но забытый при слиянии; сайт: снята пара устаревших чисел и одна ошибка перевода (TLS в английской половине записи 0.6.2).

Гейты доказуемости не двигались, всё ещё 2 из 7 на 3 сентября 2026 (КРИТЕРИЙ.md).

• Формула Homebrew 0.7.3: sha256 взят у самого конвейера (workflow_dispatch), не пересчитан вручную (f534935)
• flang 0.7.3: версия бампнута; sha256 формулы временно от 0.7.2 — правится после сухого прогона (a537f47)

0.7.2 — 3 сентября 2026

хотфикс версии довыпущен: неверный sha256 остановил v0.7.1

Метка v0.7.1 не дошла до публикации: архив для Homebrew был собран вручную (io-запуск release-in-c.flang был на тот момент недоступен), и его sha256 не совпал с тем, что собрал сам конвейер выпуска на теге. Шаг «Сверить хеш архива с формулой Homebrew» это поймал и остановил всё до GitHub Release и npm — под v0.7.1 не вышло ничего. Тег не удалялся (запись запрещена), просто пропущен; эта метка — то же дерево плюс формула с sha256, посчитанным локально тем же io-рецептом, что и сам конвейер, не вручную.

Содержательно всё то же, что должно было быть в 0.7.1:

ЧТО СЛОМАЛОСЬ. FLANG_VERSION был вшит буквально в двух местах (flang/src/emit/c/flang_repl.c, bootstrap/flang_repl.c) и не менялся при бампе версии в package.json — двоичный 0.7.0 на flang --version отвечал «0.6.2», на два релиза позади. Через brew ставился пакет «0.7.0», а сам двоичный называл себя старым именем (задача 9959).

ЧТО ПОЧИНЕНО. Обе константы → 0.7.2. Формула Homebrew (packaging/homebrew/flang.rb) несёт sha256 архива этой метки; тап digitable-lol/homebrew-tap обновляется тем же приёмом следом за публикацией.

Гейты доказуемости не двигались, всё ещё 2 из 7 на 3 сентября 2026 (КРИТЕРИЙ.md).

• flang 0.7.2: версия, реальный sha256 архива, группа отмены у build-macos (ae58085)
• Формула Homebrew: реальный sha256 архива 0.7.1 с конвейера, не ручной (597a778)

0.7.1 — 3 сентября 2026

хотфикс: --version больше не врёт

Хотфикс, не про гейты доказуемости — они не двигались, всё ещё 2 из 7 на 3 сентября 2026 (КРИТЕРИЙ.md).

ЧТО СЛОМАЛОСЬ. FLANG_VERSION был вшит буквально в двух местах (flang/src/emit/c/flang_repl.c, bootstrap/flang_repl.c) и не менялся при бампе версии в package.json — двоичный 0.7.0 на flang --version отвечал «0.6.2», на два релиза позади. Через brew ставился пакет «0.7.0», а сам двоичный называл себя старым именем (задача 9959).

ЧТО ПОЧИНЕНО. Обе константы → 0.7.1. Формула Homebrew (packaging/homebrew/flang.rb) поправлена на архив этой метки; тап digitable-lol/homebrew-tap обновляется тем же приёмом следом за публикацией.

СВЕРХ ХОТФИКСА, тем же диапазоном коммитов: задача 8651 — часть шагов CI была названа транслитом, поправлено на английский; docs/site/numbers.json — на сайте застряла версия 0.6.2.

• Формула Homebrew и задача 9959: хотфикс 0.7.1 задокументирован (ef9615d)
• Хотфикс 0.7.1: flang --version говорил 0.6.2 — на два релиза позади (99f97b7)
• Формула Homebrew: version 0.6.2 -> 0.7.0 — пропустил при первой правке (3ca0764)

Ещё 4 правки языка снаружи не меняют.

0.7.0 — 3 сентября 2026

библиотека шире, а главная работа — поиск собственных обманов

За две недели от 0.6.2 до заморозки легло 2441 коммитов (счёт: git rev-list --count v0.6.2..4df82447). Правил, меняющих язык снаружи, из них 617 по правилу видимости самого журнала; ниже они сведены в восемнадцать строк, а 1824 остальные язык снаружи не меняют. Строки ниже — сводка, а не перечень: две с половиной тысячи коммитов не перечисляются.

ЧЕГО В ЭТОМ ВЫПУСКЕ НЕТ. Язык НЕ формально-доказуемый. Критерий записан семью гейтами; на 3 сентября 2026 взято 2 из 7 — Г1 (ядро выдаёт объект доказательства) и Г3 (размер доверия назван числом). Г2 был взят 31 августа и снят тем же вечером: ложь дошла до кода 0. Г4, Г5, Г6 и Г7 не взяты. Честная формулировка — «не формально-доказуемый, взято два гейта из семи».

ЯДРО СПОСОБНО ДОКАЗАТЬ ЛОЖЬ. При развёртке вызова ядро подставляет довод под связыватель того же имени, получает тавтологию и печатает «доказано обо всех входах» про утверждение, ложное на каждом испробованном входе (задача 9618). В сегодняшнем корпусе такого доказательства нет: померено 0 из 240 — ни одно из 240 утверждений, числящихся доказанными, этой дорогой не идёт (замер 3 сентября 2026). Мест захвата в дереве 33, под доказанным утверждением стоят 12, но с 86 записями корпуса они не пересекаются. Проверка постусловия из напечатанного кода при этом не снимается: ложно «доказанное» свойство всё равно проверяется при работе.

ДОЛЯ КОРПУСА, ПРОВЕРЕННАЯ НЕЗАВИСИМЫМ ЧЕКЕРОМ, — 0,00 %. Ни одно утверждение корпуса не проверено чекером, собранным без единой строки от flang: 0 из 240 (замер прибором flang/proof/доля-корпуса.sh на этом же стволе 2 сентября 2026; перемерено 3 сентября дважды независимо — тот же ноль). Прежде называвшиеся 0,83 % (2 из 240) завышены и сняты: замер шёл на невлитой ветке a/vremennoe-v-dereve, а оба «проверенных» утверждения были одним и тем же заявлением, встретившимся дважды. Чекер ствола ключа --по-утверждениям не знает вовсе, так что на выпускаемом дереве этот вопрос сегодня нельзя даже задать.

ЧТОБЫ ПЕРЕПЕЧАТАТЬ КОМПИЛЯТОР СЕМЕНЕМ 0.7.0, НУЖЕН КЛЮЧ --предел-глубины 200000. Вшитый предел 20 000 (#define FL_MAX_DEPTH, bootstrap/flang_runtime.h:10) упирается в одну машинно написанную строку постусловия в 90 286 кодовых точек — flang/self/emit-python.flang:3779 на замороженном стволе. Без ключа связывание исходников падает; с ключом проходит (задача 9957). Раскрутка на этом не замкнута: сторож проверял, что семя собирается и отвечает, а не что оно умеет напечатать компилятор.

Задачи 9611–9617 о находках этих двух недель лежат в дереве выпуска (tasks/). Задачи 9618–9622, 9953, 9957 и 9958 записаны после заморозки и в это дерево не вошли.

• Надзор на js: опознавать конструктор тождеством полей, а не арностью (813ff19)
• Формула Homebrew: ссылка и хеш на 0.7.0 (2ec3375)
• Выпуск 0.7.0: компилятор перепечатан начисто с замороженного ствола (d926eb2)
• feat(emit): ключ --no-postconditions печатает код без сторожей обещаний, а ворота остаются на месте (e9f0b95)
• docs(семя): «двенадцать минут» на печать — число, которого не подтверждает ни один замер (efe01b6)
• feat(Г4): прибор доли положен в дерево — и он даёт карту работ с ценой каждого шага (0b8fb14)
• fix(документы): «ходов вывода нет нигде» — мерили не ту строку; и три столкновения имён сняты (9bce6aa)
• docs(зеттель): проба порчей, которая ничего не испортила, выглядит как успех (499edf2)
• feat(сторожа): столкновения ВТОРОГО вида — два имени, одна латиница (271a8b7)
• feat(суд ядра): видны имена и секунды частей тяжёлой стадии (de7067f)
• docs(задачник): семь подделок проходят на ветке Ч201, в стволе не проходят — проверено старшим (b6fd065)
• docs(задачник): у проверяльщика нет потолка размера, а он вырос на 846 строк за день (5bd8b85)
• docs(задачник): мест, которыми пересборка ломает второй проверяющий, ТРИ а не два (2abdbfa)
• perf(сборка): столкновение имён ловится перед судом ядра и только на печати в C (2778919)
• feat(проза): число, набранное в прозе рукой, стережётся прибором и датой — и 77 разошедшихся чисел исправлены (c84dca7)
• perf(ядро): «Переписать до неподвижной» выходит, как только проход перестал менять терм (e6b22a2)
• feat(проверка): ключ «flang check --быстро» говорит «не смотрел», а не «доказано» (75815fd)
• feat(язык): у «Продолжения» есть четвёртый вариант «Не проверено» — проверка может сказать «не смог», а не только «нашёл беду» (a7ea851)
• docs(задачник): 1311 — половина чекера возвращена, запрет сменился на другой (04c701f)
• test(чекер): пробы на половину ячеек Ч56, Ч71, Ч76 и Ч87 — иначе её не сторожит ничто (5c7a919)
• fix(чекер): читать исходник так же, как его читает язык — павший гейт Г2 (починка Ч126) (fa017ef)
• feat(чекер): половина ствольного чекера, писанная ячейками Ч56, Ч71, Ч76 и Ч87, наконец в стволе (89baa02)
• fix(печать): «Обойти занятое целью C++» переименовано — третье столкновение того же рода (cd5a9f2)
• feat(перечни): перепись перечней, набранных руками, и три сторожа, краснеющих на подлоге (04c4222)
• feat(запись): печать несёт sha256 исходника, терм при номере строки и оглавление списочных литералов (841c3f3)
• docs(задачник): половина чекера не возвращалась в ствол — перепечатка до неё ломает дерево (9503eda)
• docs(задачник): сверке семени нужно 64 ГБ и 12 часов, а не 259 ГБ; три счёта ходов сведены на одну линейку (c735342)
• feat(сторожа): вопрос «запущен ли я напрямую» задан одним словом во всех местах, и это стережёт отдельный сторож (fbc5654)
• docs(ядро): врезка о неотрицательности по построению называет все девять случаев, а не пять (ee2f9e0)
• feat(службы): служба чтения файла и опрос ввода-вывода хозяина названы в заметках, и заметка о молчащей встроенной сумме лежит в дереве (2888ec9)
• fix(периметр): сторож «аксиом ноль» читает все три файла ядра решений, а не один, и узнаёт довод по началу заголовка (0998bde)
• feat(ведомость): вердикт ядра называет ПРАВИЛО, которым терм принят, а не одно только число шагов (c267573)
• fix(прогоны): путь временного каталога раскрывается перед сличением, и уборщик перестаёт молча оставлять узлы живыми (23f650f)
• feat(сведение): «сведено ядром» записывается ходами, и подделка сведения отвергается проигрыванием, а не словом (8a3b8ea)
• fix(ядро): минус ноль считается по правилу языка, а не отождествляется и не рубится заслоном (fe884ac)
• fix(версия): версия на страницах и в man-странице берётся из объявления пакета, а не набирается руками (359eb17)
• feat(ворота): сверка правил делится на половины, и половина зовётся своим словом, а не прежним зелёным (ddce6be)
• feat(чекер): независимый чекер на C, его пробы и рецепт сборки лежат в дереве, а не во временном каталоге (e8380e2)
• build(semya): kompilyator perepechatan - tail call vernut, 2783 proverki snyaty (c15f669)
• test(sets-oracle): ведомость примеров названа снятым числом — 410 410 0 12, своих было 0 (c99fdcc)
• refactor(proverki): проверка слоя отказов названа английским именем файла, как велит AGENTS.md (ca20ecc)
• feat(emit): ключ --no-check печатает без ядра доказательств, и печать больше не молчит об этом (2c86769)
• fix(refs): счёт строк failures.flang перемерен после правки — 1936, а не 1916 (8ed873f)
• fix(refs): ссылки на сторожей, снятых 105943cd, названы правдой в тринадцати местах (3b5e366)
• test(sets-oracle): двенадцать своих примеров на восемь функций — зелёное больше не держится на чужом (ee6653f)
• test(failures): слой отказов процесса ввезён и судится — 18 утверждений на каждый пуш, вход печати не подорожал (63f4691)
• perf(proof-kernel): развёртка находит определение первым совпадением, а не перебором всего списка (8a4fd04)
• fix(ведомость): отказ ведомости спрашивает несудимое, а не всё объявленное — 15 файлов flang/conc получили приговор (c143a3c)
• feat(io): словарь ввода-вывода знает чтение доводов вызова — поручений 22, откликов 20 (4884aff)
• fix(wire): обещание, повторявшее два соседних, снято — пример postgres снова укладывается в предел шагов (7ed7507)
• fix(kernel): приведённое сравнение носит своё имя и не сталкивается со «Сравнением» печати JSON (e605f64)
• proof(emit-java): 27 доказанным функциям дописаны примеры, сторожей снято 28 (f08bf4a)
• proof(emit-go): 11 доказанным функциям дописаны примеры, сторожей снято 12 (33656df)
• feat(kernel): цель «Е не меньше Г» берётся правилом порядка — у зеркала фактов появилось зеркало цели (c18c161)
• fix(emit): печать в python и csharp отказывает на объявленной конкурентности, а не выбрасывает её молча (270018f)
• proof(self): две цели «не равен» переписаны в «не (… равен …)» и получили приговор (eb12445)
• feat(kernel): из «А не больше Б» и «Б не больше В» ядро выводит «А не больше В» через названную середину (c2735c4)
• proof(emit-csharp): 93 доказанным функциям дописаны примеры, сторожей снято 258 (456b4c1)
• proof(self): четыре молчавших строителя названы обещанием — семь утверждений трёх файлов стали доказанными (8a7565f)
• fix(пределы): врезка conc.flang называет нынешний потолок шагов, а не триста миллиардов (f18b0c2)
• feat(emit-cpp): девятая цель печати — C++, и корпус на ней проходит целиком: 114 программ из 114 (1384f65)
• feat(processes): написаны четыре ненаписанных правила — начальное состояние, непокрытый отказ, вид литералом, приём варианта (963b2fc)
• feat(io): словарь ввода-вывода знает чтение переменной среды — поручений 21, откликов 19 (bd44342)
• feat(kernel): пятый ход входит под связыватель, не связавший ни одного имени условия (c3a1b2e)
• feat(kernel): ядро считает постоянные вокруг одной длины и знает длину склейки выписанным списком (00ef834)
• fix(self): приговор check --proof считается по входному файлу, а не по его замыканию (2596779)
• proof(proof-initial): 53 доказанных постусловия получили пример (01c8639)
• proof(emit-rust): 32 доказанных постусловия получили пример (cb32f36)
• fix(вычислитель): глубина не растёт с числом витков — круг прогона снова расплющивается батутом (74ae40c)
• proof(emit-python): 131 доказанной функции дописаны примеры, сторожей снято 323 (c753d31)
• proof(examples): 97 примеров сняли 117 сторожей с семи примеров дерева (21042d1)
• proof(emit-c): 101 доказанной функции дописаны примеры, сторожей снято 109 (2367c4d)
• build(semya): otkat perepechatki - novoe semya lomaet sborku po glubine vyzovov (43bf2f2)
• proof(emit-js): хвостовой пробел снова под примером — сторож починенного обещания больше не мешает (39c62d3)
• feat(stdlib): драйвер sqlite дочитывает переполнение ячейки и вписывает строку в готовый лист (716abca)
• proof(emit-csharp): 129 примеров сняли сторожа с 130 доказанных обещаний (6071c3d)
• fix(emit-js): «Пробельные JS» обещало четыре знака, а возвращает шесть — обещание стало правдой и доказалось (ac48c01)
• feat(processes): flang check спрашивает слой процессов — из двенадцати подделок молча не принимается ни одна (9e0c777)
• proof(lexer-core): доказанным постусловиям лексеров и разборщиков дописаны примеры (08a25d1)
• proof(failures): 47 доказанных постусловий не едут в напечатанный код (0e9715f)
• proof(self): 75 доказанных постусловий получили примеры и перестали ехать в напечатанный код (0820825)
• proof(interpret): 117 примеров снимают приговор с проверки при работе у 106 функций (df3209c)
• proof(types): 88 доказанных функций получили примеры, и сторож теперь снимаем (0aadc4a)
• proof(emit-js): 29 доказанных постусловий больше не едут в напечатанный код (37fd883)
• fix(пределы): восемь мест дерева называют нынешний потолок шагов, а не прежний (c1e7543)
• proof(emit-java): 44 доказанных постусловия теперь с примерами — сторожей снято 160 → 204 (ac9a3cd)
• feat(emit/cpp): у цели C++ есть лицо — пространство имён, исключение, арена RAII и печать значения в поток (64690dd)
• proof(totality): 108 примеров 103 доказанным функциям — сторожа снимаются со 110 постусловий (9532bb5)
• proof(conc): 88 доказанных постусловий conc.flang получили примеры (3fff8ca)
• proof(emit-go): 43 примера на 42 доказанных функциях печати в Go (0953352)
• proof(stdlib): цель «Положительного» доказана — вместо двучлена «не равен» стоит отрицание «не (… равен …)» (617fd28)
• proof(emit-elixir): 26 доказанных постусловий получили примеры — 157 проверок снято вместо 131 (6d866c4)
• proof(ведомость): 93 доказанных обещания получили примеры — вторая половина условия печати (bee8e53)
• proof(emit-python): 99 примеров на 36 доказанных функциях (94ec8ca)
• proof(parser): 41 пример у 21 доказанной функции снимает 35 сторожей (2eb8a3e)
• proof(emit-c): 36 доказанных функций получили примеры, сторожа сняты с 40 постусловий (80616ad)
• proof(lsp): 71 доказанным постусловиям сервера дописаны примеры — снято 99 сторожей вместо 28 (944e20f)
• build(semya): компилятор перепечатан — отставание семени с сорока пяти файлов до пяти строк (5299600)
• proof(ведомость): два доказанных обещания склонения получили примеры (bcc5248)
• proof(толкователь): семь доказанных обещаний получили примеры — вторая половина условия печати (740998f)
• proof(lsp): восемь доказанных обещаний больше не едут проверкой в напечатанный код (8765e5f)
• proof(оболочка): четыре доказанных обещания больше не едут проверкой в напечатанный код — им дописаны примеры (fcbe754)
• proof(emit-csharp): три обещания о числе имён доказаны — ядро сличает ТЕРМ цели, а не её значение (cd89d2f)
• proof(aes): тег GCM обеих длин ключа доказан — «пусть» в возвращаемом выражении держит наследование постусловия (412d0e9)
• proof(aes): двенадцать обещаний о длине доказаны — ядро видит длину списочного литерала и не видит длины свёртки (900f98e)
• proof(parser): 28 обещаний разборщика записаны стороной, к которой у ядра есть правило (d9d6aeb)
• fix(flang/self): «Числовых имён JS» обещало девять при десяти — замкнутая ложь снята пересчётом (b7c9e64)
• feat(check): объявление «план» судится — судья ввезён в замыкание (7bac560)
• perf(io): обещания слоя планов либо доказаны с примером, либо сняты (6ee3f78)
• fix(check): двоичный признаётся, что не судит объявление «план» (1145f32)
• fix(obyazatelstva-i-yadro): пример ждал прежнего отказа ядра, и файл не судился вовсе (758ffdf)
• proof(proof-initial): цель через «не (… равен …)» вместо «не равен» — доказано 82 из 94 против 70 (e99267b)
• fix(печать): длинная строковая постоянная едет октетным массивом, и напечатанное семя снова собирается своим же Makefile (f36239c)
• fix(доказательства): бюджет сверщика поднят до замеренного — двухсот миллионов не хватало (e9088c3)
• fix(пределы): зашитый предел у conc и datetime опускал потолок, а не поднимал (1c657a7)
• fix(ведомость): предел шагов тратят два счётчика, а ведомость печатала один (b160381)
• fix(доки): напечатанные команды запуска планов работают как напечатаны — их было тридцать пять, и все отказывали (548e529)
• fix: четыре обещания, опровергнутых прогоном, — команды, ключ, метки лицензии и упавшая проба (a62e021)
• docs: числа прозы пересняты с дерева — тридцать с лишним мест, у каждого рядом команда (95c4b41)
• perf(ядро): прогоны для ядра сужены до функций под термом, подготовка программы одна на все примеры (1a5f81a)
• fix(emit): китайская программа печатается — буквы поверхностей письма перестали резаться как препинание (5d8a0d0)
• proof(self): девять «В ёлочках» доказаны — парная склейка и «плюс 1 плюс 1» вместо «плюс 2» (70143cd)
• fix(emit): шапка напечатанного указывает на существующий файл (01fc487)
• feat(scripts): долг считается по всем языкам, а не по одному — опись прогоном и потолок в проверках (4d89b33)
• proof(core/json): вложенная склейка вместо списка — доказано 3 → 18, сторожей в напечатанном 25 → 22 (6d2bec7)
• fix(guard): сторож кодов побежал впервые, сторож справки видит дерево целиком, сырого нулевого байта в дереве не осталось (be7fef7)
• refactor(naming): 206 модулей примеров и библиотеки названы по-английски — напечатанный файл больше не транслит (03f0359)
• fix(guard): сторож столкновений делит отчёт на настоящие замыкания и слитую библиотеку — работа imena зелёная, разряд 1 пуст (d26c6be)
• feat(self): процессы, надзор и прогоны судятся тремя правилами — слой на flang и ввоз в компилятор (a3a4c59)
• fix(link): «В ёлочках» связывания названа по слою — замыкание компилятора связывается без FLANG_DUPLICATE_NAME (4f57a0c)
• proof(self): у каждого постусловия сетки есть пример (3c1acd8)
• proof(self): у каждой функции оракула функтора есть пример при обещании (6dfc472)
• proof(self): у всех 43 обещаний оракула законов есть исполняемый пример (98350d3)
• docs(zettel): поправка моей ошибки — на замыкании компилятора перебор описаний берёт 26,69 % ЧАСОВ, а не процент; вывод «время не в поиске» был снят на слишком малых входах (cae352f)
• feat(runtime): предел глубины идущего двоичного двигается ключом, а не только пересборкой (7b4e0c3)
• test(proof): корпус приёмки правила переходности отделяет «нет переходности» от «нет её между двумя неравенствами» (cb73e52)
• feat(runtime): счёт шагов и часы отвечают на разные вопросы — прибор есть у обоих, а был только счёт вызовов (c6025c4)
• feat(runtime): режим пульса — идущая программа сама пишет в файл, где она; возражение объёмом было завышено в тысячу раз (4a26cf0)
• proof(conc): два обработчика опроса хозяина доказаны — стены на пятнадцати ветвях не было, не хватало примера (c737985)
• proof(conc): обработчики процессов обещают, что возвращают — 62 доказанных обещания и ноль байт в напечатанном (ac8df2e)
• perf(emit): вход разбирается один раз на команду — emit короче на 17,68 с, check на 18,14 с (c7b1a12)
• docs(proof): край по пустому списку не открывается и третьим написанием — 64 обещания на троих, ноль доказанных (0659d35)
• proof(stdlib): numbers 33 → 37 доказанных и json 45 → 47, а стены datetime и higher-order названы прогоном (c38ed2e)
• feat(runtime): к идущей программе подключаются сигналом — kill -USR1 называет функцию, глубину, витки и вызов для повтора (948470d)
• test(proof): малый сводитель несёт примеры — снятых проверок при работе 5 → 52 (5c40e90)
• test(proof): сверщик доказательств несёт примеры — снятых проверок при работе 31 → 208 (2d91a1e)
• test(https): шести доказанным постусловиям векторов RFC 8448 дописаны примеры — снято шесть проверок (d5d5c07)
• proof(https): у привета TLS доказаны все двенадцать дописанных обещаний, и снято пятнадцать проверок (120d6c0)
• proof(https): у системной связки корней доказаны все шесть дописанных обещаний (36c4347)
• proof(packaging): обе проверки установки доказаны нацело — 31 дописанное обещание, 31 доказанное (bc1d591)
• fix(tls): «Ход по парам» вписан в список только — два примера https снова доходят до ядра (ad21e1d)
• perf(runtime): счётчик витков заряжает и встроенные формы, обходящие вход, — разброс постоянной 1284× → 148× (ddad2d7)
• perf(stdlib): 2262 — разбор chunked-тела копит куски списком: на 800 чанках памяти в 2,49 раза меньше, а рост остановился (показатель 0,84 → 0,01) (5c501d8)
• test(types): у «Одинаковых видов» и «Сопоставить» появились примеры — сетка с нуля значений поднялась до двух (c92a2c9)
• test(self): 114 примеров к доказанным постусловиям четырёх файлов слоя алгебры — снято 127→200, 130→175, 125→155, 127→138 (a65cabc)
• test(self): два примера «Открыть строку» — второй обход строки по символу тоже стал циклом (455cf41)
• docs(tasks): 9088 — истинная дизъюнкция роняет файл, если частичный член стоит первым; лечится порядком (8ba38d0)
• fix(compiler): отказ о несудимых объявлениях говорит правду — судья вшит и судит три поверхности, а правил для процессов нет ни одной строкой (9eb3a2c)
• docs(tasks): 9088 — граница дизъюнкции по ветвям в условиях, а не в числе ветвей (8f041bd)
• perf(stdlib): склейка строки свёрткой в постусловии «Кодов нулевых» заменена одним проходом — пик на 4000 знаках −5,9 %, значение то же на пяти входах (612a41f)
• test(self): семь примеров четырём звеньям распавшихся батутных групп (a33b766)
• perf(stdlib): «Длина» считает звенья свёрткой — глубина 1001 → 4 на тысяче (dad1ef6)
• docs(tasks): 9088 — число модуля двигается вместе с его ввозами: http вырос на девять обещаний utf8, не изменившись сам (2bddc5f)
• proof(conc): 88 примеров и пять доказательств сняли 116 проверок при работе — доказанных в flang/conc 176 → 181, тела функций не тронуты (562a07d)
• proof(stdlib): пять худших модулей — 132 доказанных из 275 стали 175 из 318, и сетка не выросла ни в одном (4332b15)
• perf(interpret): словарь описаний собирается свёрткой — вторая стена глубины снята, 10005 кадров на десяти тысячах против одиннадцати, память 20,4 → 6,4 ГиБ (9b66cbd)
• feat(examples): служба на процессах держится под отказом — надзор поднимает счётчик, а служба отвечает дальше (669199e)
• feat(scripts): список расширений имени файла один, «.фланг» в нём есть, и двадцать мест отбора сверяются с ним прогоном (13f8a56)
• feat(cli): «flang --машина» снимает постоянную этой машины — 1 178 340 витков в секунду на разборе, и это НЕ одно число (2e9d777)
• fix(runtime): счётчик витков видит фильтр, отображение и свёртку — было 0 витков на любой длине, стало виток на элемент (bbfd6cc)
• perf(interpret): обход функций программы стоит постоянной глубины вместо кадра на функцию — 10003 → 5 на десяти тысячах (a244a08)
• fix(kernel): в примерах ядра вызовы заменены литеральными вариантами — примеры не вычисляются, годятся только литералы (8171c0e)
• fix(adr): все пятнадцать решений названы одинаково — номер в имени файла, и проверка за этим следит (b4c3085)
• test(proof-probes): дверь на границе слоя оставляет одну недоказанную функцию вместо круга, и круговой перевод сходится знак в знак (62bd398)
• perf(link): слияние и второй проход не перебирают список по имени — на 800 функциях память связывания 13,0 → 5,6 ГиБ, вывод байт в байт (168b674)
• proof(stdlib): вопросительные знаки и пустое имя дня недели доказаны замкнутой целью — datetime на 27 обещаниях против 21 (de15360)
• proof(stdlib): длина знака из таблицы в wire ядру не сводится — проба опровергнута, сетка вернулась к 36 (1a6f6bc)
• proof(stdlib): все четыре порога UTF-8 меряются и числом, и длиной списка — utf8 доказан на 60 обещаниях (e1a1eb0)
• proof(stdlib): три пробы записи в base64 опровергнуты прогоном и сняты — сетка вернулась к 26, как в базе (9148e4e)
• proof(stdlib): datetime доказан на 24 обещаниях против 21 — пусть-имя, выписанное выражением, открывает обе ветви пола дроби (35d2c23)
• proof(stdlib): wire доказан на 58 обещаниях из 94 — условная запись берёт там, где дизъюнктивная уже взяла, а не вместо неё (00d8c2a)
• proof(stdlib): utf8 доказан на 57 обещаниях из 86 — четыре яруса числовых порогов берутся, если пусть-имя выписать самим выражением (99c882e)
• proof(stdlib): base64 доказан на 77 обещаниях из 104 — замкнутая цель берёт азбуку целиком, а длину знака берёт разложение по ветвям (6c0b9f4)
• proof(scripts): восемнадцать сторожей дерева доказаны на 141 утверждение больше — своей доли 289 → 433 доказанных (6e4ef9e)
• test(kernel): ядро доказательств показано примерами — 65 функций трёх файлов получили по примеру, снятому с их же тел (e70a221)
• perf(runtime): равенство записи, варианта и списка отсекается одним указателем — 462,41 с → 14,35 с на одной работе, вывод знак в знак (12500ef)
• test(examples): четырнадцать векторов из RFC и NIST названы примерами — снято четырнадцать проверок при работе (6f992d8)
• proof(tls): свёртка пар вынута из-под проекции, а тринадцать доказанных обещаний перестали стоить сторожа (86bdfc5)
• fix(sha1): ведомость доказательств снова печатается — пример с настоящим HMAC не влезал в предел шагов (a405067)
• test(shortener): почта примера переписана прогоном — три октета на «к1», а не два знака (b6df460)
• fix(shortener): путь, закодированный процентами, доводится до знака — служба работает из браузера (56edc89)
• fix(hmac): свёртки вернулись под проекцию — съёмники роняли kdf и sha1 целиком (9d38c60)
• refactor(hmac): свёртки вышли из-под проекции — «Принцип свёртки» их всё равно не поднял (c33dc79)
• test(sha1): все доказанные обещания SHA-1 и вывода ключа снимают проверку при работе (d8c21e5)
• docs(zettel): библиотека доказана на 62 % — ведомость по всем сорока модулям, а не по шести (9ae43c8)
• test(iso): девять доказанных постусловий закона изоморфизма проверены примерами — снято 125 → 134 (ec4f431)
• fix(examples): последние шестнадцать файлов снова читаются семенем — «неотрицательное» в позициях типа возвращено к «нат» (99030f1)
• test(zapis): сорок доказанных постусловий записи доказательства проверены примерами — снято 124 → 164 (d9ac14c)
• perf(stdlib): восемнадцать примеров в sqlite сняли 22 проверки при работе — 115 стало 137 (a0087af)
• fix(packaging): packaging/install-check.flang снова читается семенем — «неотрицательное» в позициях типа возвращено к «нат» (f30088d)
• fix(proof): flang/proof/map/refusal-order.flang снова читается семенем — «неотрицательное» в позициях типа возвращено к «нат» (78fb0bc)
• fix(proof): flang/proof/map/refusal-boundaries.flang снова читается семенем — «неотрицательное» в позициях типа возвращено к «нат» (5efbfba)
• fix(proof): flang/proof/map/order.flang снова читается семенем — «неотрицательное» в позициях типа возвращено к «нат» (8dd797a)
• fix(proof): flang/proof/map/boundaries.flang снова читается семенем — «неотрицательное» в позициях типа возвращено к «нат» (14abf82)
• fix(proof): flang/proof/map/abilities.flang снова читается семенем — «неотрицательное» в позициях типа возвращено к «нат» (328872f)
• fix(proof): flang/proof/examples/segment.flang снова читается семенем — «неотрицательное» в позициях типа возвращено к «нат» (85bfe5c)
• fix(proof): flang/proof/examples/if-over-a-segment.flang снова читается семенем — «неотрицательное» в позициях типа возвращено к «нат» (7595cad)
• fix(proof): flang/proof/examples/forgery-if-without-descent-theorem.flang снова читается семенем — «неотрицательное» в позициях типа возвращено к «нат» (0a8a98b)
• fix(proof): flang/proof/examples/forgery-if-without-descent.flang снова читается семенем — «неотрицательное» в позициях типа возвращено к «нат» (1fddd87)
• fix(proof): flang/proof/examples/corpus-natural.flang снова читается семенем — «неотрицательное» в позициях типа возвращено к «нат» (3418d27)
• fix(proof): flang/proof/examples/corpus-natural-ceiling.flang снова читается семенем — «неотрицательное» в позициях типа возвращено к «нат» (6a4ca18)
• fix(proof): flang/proof/examples/corpus-factorial.flang снова читается семенем — «неотрицательное» в позициях типа возвращено к «нат» (7b45ae4)
• fix(proof): flang/proof/подделки/счёт-частей-правда.flang снова читается семенем — «неотрицательное» в позициях типа возвращено к «нат» (90d6f45)
• fix(examples): examples/paths/shortest-path.flang снова читается семенем — «неотрицательное» в позициях типа возвращено к «нат» (1dc047c)
• fix(examples): examples/money/exact-decimal.flang снова читается семенем — «неотрицательное» в позициях типа возвращено к «нат» (8f931aa)
• fix(examples): examples/measure/natural.flang снова читается семенем — «неотрицательное» в позициях типа возвращено к «нат» (2b75b3b)
• proof(rosetta): «взять нисколько первых» у сортировки слиянием доказано индукцией по списку — сквозь разбор, а не мимо него (76020e3)
• proof(rosetta): ещё пять переводов доказаны парами, и перекос пары palindrome закрыт — обещание было только по-русски (ff93669)
• proof(leetcode): шаг свёртки вынесен из лямбды и доказан, а у пустого бора цель замкнута (d88770b)
• proof(rosetta): FizzBuzz и римские цифры доказаны на ОБЕИХ поверхностях — 9 обещаний по-русски, 9 по-английски, вердикты совпали (4286dd3)
• proof(leetcode): у шести деревьев край по варианту доказан — лист пуст, симметричен, беспутен и ничем не ограничен (55165a3)
• test(monad-expand): пятьдесят семь доказанных постусловий разворачивания монад проверены примерами — снято 1 → 58 (a97e44c)
• test(bounded): восемьдесят три доказанных постусловия оценки витков проверены примерами — снято 126 → 209 (dc65c13)
• test(tls): flang сам сходил к настоящему узлу по 443 и разобрал его ServerHello — curl не участвовал (a88d87d)
• feat(tls): клиент TLS 1.3 умеет собрать ЗАКРЫТУЮ запись, свести Finished и разобрать Certificate — сверено с векторами RFC 8448 (8afd20e)
• perf(stdlib): двенадцать примеров у шагов свёрток сняли 21 проверку при работе в трёх модулях (6e6d160)
• fix(shortener): Content-Length ответа считается октетами, и клиент получает тело целиком (7646750)
• test(parser): пятьдесят семь функций разборщика с доказанным постусловием получили примеры (6b23e39)
• test(types): двадцать конструкторов и переворотов типа с доказанным постусловием получили примеры (16ade64)
• test(lexer): двадцать функций лексера с доказанным постусловием получили примеры — токены, состояние и склейка (4427bad)
• proof(leetcode): равенство варианту делит цель и через вложенный разбор — обход листа и два листа-близнеца доказаны (18cdc94)
• proof(x25519): квадрат поля доказан теоремой поверх сеточного постусловия — доказано 18 → 19 (6c5380d)
• proof(rsa): единица разрядами доказана — цепочка сомкнулась через отобразить, доказано 15 → 16 (0cc9b76)
• test(scram): три доказанных обещания счёта подписи получили примеры — проверок при работе снято 163 → 166 (c25dfc3)
• test(x25519): девять доказанных обещаний Curve25519 получили примеры — проверок при работе снято 8 → 17 (2f6f93c)
• test(ecdsa): двадцать восемь доказанных обещаний P-256 получили примеры — проверок при работе снято 38 → 66 (2e5e22c)
• test(rsa): у всех пятнадцати доказанных обещаний RSA есть примеры — проверок при работе снято 8 → 15 (ba0c7ab)
• test(defunc): сто девятнадцать доказанных постусловий понижения проверены примерами — снято 3 → 122 (6635c76)
• proof(leetcode): ещё восемнадцать задачек несут охрану из тела — 42 обещания, 42 доказано (e99fda6)
• proof(leetcode): у девяти задачек охрана списана из тела — 22 обещания дописано, 22 доказано, сетки ноль (c549be9)
• test(emit-java): тридцать два помощника печати в Java показаны примерами — снятых проверок при работе 6 → 39 (5812b4f)
• test(aes): все 209 доказанных обещаний AES снимают проверку при работе, а не 134 (326dce2)
• perf(obligations): список обязательств собирается свёрткой, а не спуском — 6139 обязательств перестали не влезать в 45 ГиБ (5d8043e)
• test(factcheck): семьдесят пять доказанных постусловий факт-чекинга проверены примерами — снято 1 → 76 (1b0d6aa)
• test(emit-rust): восемнадцать помощников печати в Rust показаны примерами — своей прибавки 18 проверок (694f133)
• proof(stdlib): равенство нульместному варианту в охране дало 17 доказанных обещаний в трёх модулях, и сетка не выросла ни на одну (ff5b02c)
• proof(tls): длина вектора с номером доказана теоремой на голом вызове (164520a)
• test(proof-probes): одна проба держит все оси спорного замера — 23 записи одной мысли, 21 доказана (d79c164)
• proof(automaton): девять функций автомата, о которых нечего было сказать, доказаны нульместным вариантом и замкнутой целью — 98 → 121 из 127 (aa76fd2)
• test(totality): примеры дописаны ещё тридцати трём функциям с доказанным постусловием — всего их пятьдесят две (ddf98a4)
• fix(hashmap): у «Звеньев грозди» вместо украшения стоит причина, по которой обещания там быть не может (a3918b2)
• test(monotone): восемь доказанных постусловий закона монотонности проверены примерами — снято 31 → 39 (b25fc66)
• proof(der): цепочка «Собрать голову» → «Разобрать голову» достроена до конца — 46 → 51 (002401e)
• test(emit-go): восемнадцать помощников печати в Go показаны примерами — своей прибавки 21 проверка (4868ac8)
• docs(adr): TLS собирается поверх октетной пары без нового слова — в дереве 6535 строк криптографии на flang (4985f36)
• proof(higher-order): охрана из тела дословно закрыла восемнадцать обещаний о функциях-значениях — 28 → 46 доказанных, снятых проверок 28 → 46 (7fb0e5f)
• test(self): семнадцать функций языкового сервера и встроенных форм получили примеры (78d1160)
• docs(math): шапки обоих файлов называют границу «терм против литерала» и цену выноса шага свёртки (f678a62)
• proof(math-classics): шаг склейки, длина пустого списка и отображение тождеством доказаны — списков 37 утверждений, доказано 16 (4de3000)
• proof(math-classics): монотонность сложения берётся при литеральной прибавке и не берётся при прибавке-терме — 67 утверждений, доказано 29 (acab9aa)
• proof(stdlib): множества доказаны втрое лучше — 5 из 19 стало 22 из 34, и заявка на правило ядра закрыта выносом шага (dfb6a1b)
• test(partialorder): двадцать одно доказанное постусловие закона порядка проверено примерами — снято 8 → 29 (8839197)
• test(self): постоянные распределённого узла, командной строки и службы MCP получили примеры (d62aa03)
• proof(der): у головы DER доказаны все четыре поля — достройка цепочки дала 34 → 46 (d6ff271)
• docs(site): довод «язык запрещает бесконечный цикл» опровергнут прямо на странице — четыре строки исходника и вывод проверки (250e8ff)
• feat(kernel): ядро переписывает «элемент К в выписанном списке» — четвёртое равенство, посылки ему не нужно (dd5dcf2)
• proof(primery): подъём постусловия через свёртку работает — три обещания MSI и распределителя доказаны индукцией (b96826d)
• fix(primery): драйвер UART снова проверяется — восемь мест типа вернулись к «нат», ведомость печатается (e08f2ed)
• feat(examples): стык через печать в C прогнан — рукописный хозяин держит цикл, flang считает решение и отбивает порченый довод на границе (b96b553)
• test(totality): у девятнадцати функций с доказанным постусловием теперь есть примеры — от «Неизвестно» до «Дописать имя в перечень» (541ce35)
• test(distributive): восемь доказанных постусловий закона дистрибутивности проверены примерами — снято 9 → 17 (6239854)
• proof(stdlib): восемь обещаний в списках доказаны — вторые ветви шагам, обе ветви «Чисел до» и три шага из лямбд (b8f6e23)
• proof(stdlib): три обещания шагам словаря доказаны, а вынос последней лямбды отвергнут замером (d2906ed)
• test(tags): шесть функций перебора тегов получили примеры — от параметров до кратчайшего кандидата (6e12eae)
• test(idempotent): девять доказанных постусловий закона идемпотентности проверены примерами — снято 9 → 18 (4ec2993)
• test(failures): сорок две функции анализа отказов с доказанными постусловиями получили примеры (0692f01)
• proof(optional): у четырёх «… или запасное» доказано, что берётся ровно вариант вызванной — 7 → 15 доказанных из 22 (ca06575)
• test(emit-c): двадцать шесть помощников печати в C показаны примерами — снятых проверок при работе 15 → 49 (334fcc7)
• proof(stdlib): в списках строк шаг свёртки и охрана из тела доказаны — 6 из 19 стало 8 из 21 (d090e82)
• proof(hashmap): гроздь отвечает про пустое место, а глубина словаря доказана и на пустом месте, и на грозди (870f508)
• proof(numbers): доказаны потолок знака, тождества деления и делимости и края НОД, НОК, степени, факториала и цифр (28f0ba2)
• proof(tree): у листа доказаны все девять краёв — размер, глубина, ключи, поиск, вставка и оба уравновешивания (77b76e5)
• test(carriers): пять доказанных постусловий отчёта о носителях проверены примерами — снято 33 → 38 (ec6c7b5)
• proof(stdlib): семь шагов свёрток в строках доказаны — вторые ветви тела и два шага, вынесенных из лямбд (8415ca0)
• test(io): у четырнадцати функций «Проверки планов» с доказанными постусловиями теперь есть примеры (630ea8f)
• test(registry): все двадцать доказанных обещаний реестра сняты из рантайма — примеров 39 → 55, снятых проверок 7 → 20 (4660bd7)
• test(commutative): шесть доказанных постусловий закона коммутативности проверены примерами — снято 9 → 15 (70afd67)
• docs(runtime): печать не ставит пика — 2 702 МиБ и до неё, и после; семя с рантаймом дерева печатает то же байт в байт при −90 % пика (3b25518)
• proof(conc): восьмое событие планировщика и два новых веления сверены на всех восьми целях — 80032 сверки, расхождений 0 (9388519)
• chore(conc): горячая замена на живом узле повторяется одной командой — bash flang/conc/bench/hot-swap.sh, код 0 (19890e3)
• docs(conc): два записанных препятствия переснято — у self/conc.flang замечаний ноль, а не 126, и hotswap.mjs в дереве нет (925b5fe)
• feat(conc): веление горячей замены доезжает до живого узла и исполняется — обработчик подменён без перезапуска процесса (e115c96)
• perf(interpret): вычислитель ищет описание по словарю, а не перебором — витков поиска на self/proof-kernel.flang 14 698 772 вместо 873 999 841 (c47a77d)
• proof(emit): печатники Python и C# — 688 дописанных обещаний доказаны все до одной, python 306 → 582, csharp 138 → 549 (277035f)
• proof(proof): ведомость 250 → 271 доказанных своих обещаний, сетка 12 не выросла (5877702)
• proof(interpret): толкователь 123 → 149 доказанных своих обещаний, сетка 15 не выросла (74e8bd4)
• feat(repl): длинный шаг говорит раз в полминуты, сколько витков истрачено и на каком он шаге (2b260b9)
• feat(kernel): строгие «меньше» и «больше» стали видом цели ядра — правило, врезка и подделка на пять лжей (918225f)
• docs(conc): число в шапке отстало на порядок — 15 против 186, вписаны снятые прогоном 200/123 (ad1b85b)
• proof(conc): планировщик — доказано 101 → 123 из своих обещаний, снимаемых проверок 2 → 29 (7a032ac)
• proof(postgres): охрана-равенство варианту с полями снимает стену «образец связывает имена» — postgres 65→81, redis 30→43 доказанных, сетка не выросла (c491e80)
• docs(examples): маркетплейс из четырёх служб проходит проверку целиком — 993 строки, все функции тотальные (1fa51cc)
• docs(raskrutka): два устаревших числа заменены снятыми — 5 ч 30 мин вместо 20 минут (e14cb03)
• refactor(yarlyki): все 82 цели ярлыка названы кириллицей — одним видом записи вместо четырёх (3523895)
• fix(emit-js): печать в JavaScript проходит tsc в нестрогом режиме — 87 замечаний из 87 сняты (d8868b2)
• perf(runtime): взятие поля сверяет сперва одни указатели — builtins.flang 78,3 → 76,5 с (258e7c4)
• proof(hashmap): обещания словаря доказаны ядром — сетка 25 → 15, обхода словаря в них не осталось (bc07b7f)
• fix(types): ложное обещание у «Только диагностики» снято — оно ломало собранный компилятор (9d6027b)
• fix(editors): подсветка Vim знает 150 понятий и 633 фразы вместо 149 и 629, и записан довод, почему девятой цели печати не будет (803df8a)
• docs(site): пять README каталогов стали двуязычными указателями, а их содержимое — страницами сайта на двух языках (13b86ce)
• docs(zettel): 191 заметка названа английскими словами вместо русских латиницей — 443 ссылки переписаны в 234 файлах (058d9f0)
• feat(editors): расширение VS Code собирается из дерева — подсветка напечатана из таблицы языка, все три расширения имени файла (6fb16ac)
• fix(self): «неотрицательное» в позициях типа возвращено к «нат» — ствол снова разбирается нынешним двоичным (e6795b0)
• proof(math-classics): из 47 классических лемм Coq и Lean ядро берёт 13 целиком — прогон, 73 утверждения, доказано 29 (9d87ec8)
• refactor(examples): проверка младшего бита вынесена из тринадцати повторов в одну функцию, вердикты не сдвинулись (6ef270e)
• proof(self): ведомость доказательства — 250 обещаний из 321, было 153; проверок при работе снято 158, было 12 (f31084e)
• proof(interpret): витки тратит ровно одно место, и это доказано — 254 обещания вычислителя несёт ядро вместо 214 (c811d6d)
• proof(kernel): у рефлексивности порядка и монотонности сложения названы посылки — три хода правила порядка (70db471)
• docs(hashmap): шапка словаря больше не запрещает ввоз — запрет стоял на ошибке, ввоз чист (aca4bdf)
• fix(repl): затенённый модуль называется вслух — чужой черновик каталогом выше больше не подменяет библиотеку молча (d77b517)
• feat(yazyk): программа на flang пишется под тремя расширениями — .flang, .fp и .фп (b6333b9)
• docs(examples): обещание про звонок MSI проверено заглушками — оно содержательно (8701acd)
• refactor(hashmap): словарь хешем параметричен по значению — строка → «З» (07783d1)
• proof(examples): драйвер MSI из ядра NetBSD переписан на flang — 85 обещаний из 93 доказаны (4577128)
• proof(aes): AES-128 и AES-256 доказаны 209 обещаниями из 337 — было 177 (91ab728)
• proof(x509): сертификат доказан 205 обещаниями из 320 — было 173 (238ce7c)
• docs(sravneniya): снято ложное противопоставление flang прувверам — теоремы руками здесь ЕСТЬ, 160 в дереве (df6b829)
• proof(crl): имя алгоритма, метка времени и срок списка доказаны из постусловий вызванных — 214→225 из 357 (7d9cfac)
• proof(tls): метки расписания и расширения привета доказаны замкнутой целью — 268→284 из 479 (5f6b232)
• refactor: места применения «нат» → «неотрицательное» по всему дереву (7eb35b9)
• fix(conc): напечатанные link.js и scheduler.js догнали свои исходники — сторож печати снова зелёный (01df4a2)
• fix(conc): сторож печати снова зелёный на трёх модулях, и distributed.mjs удалён (2836a28)
• proof(primery): распределитель памяти как чистый автомат — 79 обещаний из 89 доказаны ядром, отказ честен обо всех входах (f7dcfa8)
• proof(hashi): разглаженные тела и зеркальные охраны дали 43 доказанных в цепочке SHA-1 и 8 в SCRAM (5ef65a9)
• feat(типы): язык принимает имя «неотрицательное» рядом с «нат» (1212338)
• perf(interpret): перебор в «Найти описание» съедает 877 390 889 витков из 1 000 219 882 — 88 % проверки (a800107)
• proof(conc): живучесть трёх настоящих утверждений выражена имеющимися средствами — восемь обещаний доказаны ядром, новых слов языка ноль (8bb4078)
• perf(runtime): откат арены отдаёт куски системе — пик проверки −36…61 %, время не выросло (c439ef9)
• feat(conc): у живого узла есть решение о горячей замене — 19 функций, все с доказанным завершением, 18 утверждений из 21 доказаны (9d15ff5)
• refactor(imena): 50 файлов замеров и проверок редактора названы по-английски (0eec94a)
• refactor(imena): ещё 83 файла названы английскими словами вместо транслита (27156b2)
• feat(primery): драйвер как чистый автомат — инвариант цикла доказан ядром, 6 обещаний из 8 (b5f1023)
• feat(conc): провод узла на flang — 45 функций, все с доказанным завершением, 47 примеров зелены, печать во все восемь целей (0db9cdc)
• refactor(imena): 159 файлов дерева названы английскими словами вместо транслита (b316720)
• proof(strings): дописано звено «позиция неотрицательна» — 41 → 43 доказанных (97be11c)
• proof(utf8): начальный ход и блок суррогатов — 39 → 51 доказанных, сетка та же (d9ff266)
• proof(numbers): ветви тел выписаны охраной из тела — 12 → 24 доказанных (037fad1)
• proof(base64): азбуки и знак азбуки — 40 → 57 доказанных, сетка та же (e628241)
• proof(protokoly): вынос шага свёртки и ветвь «иначе» подняли четыре разборщика: postgres 105→114, http 45→60, redis 73→79 (087d715)
• feat(kernel): встроенная пустота «пусто Л» читается наравне с мерой нулю — охрана, которой написана библиотека, доезжает до правил (4f1a4de)
• proof(tls): записи TLS — 233 обещания доказаны ядром вместо 201 (f6f24bc)
• docs(sait): разглаживание тела меняет индукцию на прямое сведение — доказательства не только множатся, но и дешевеют (155bbb8)
• proof(crl): шаг свёртки, теоремы по свойству и ветви ряда — доказано 161 → 195 (c9b2516)
• proof(sqlite): равенство варианту разводит «разбор» по ветвям — доказано 116 → 126 (4faa586)
• proof(aes): плоское тело вместо ярусов «разбор» — доказано 140 → 177, сетка не выросла (5fffce1)
• refactor(primery): все 172 примера лежат в одном examples/ — второго каталога нет (08ba3cf)
• fix(self): cli.flang снова разбирается — цепочка «иначе если» разъехалась отступом при вставке ключа предела шагов (eccc9fe)
• feat(kernel): разбор списка выбирает ветвь по построению — выписанное разбирается точными частями, известная пустота даёт ветвь «пусто» (0069a1f)
• docs(examples): README примера-библиотеки перестал звать снятого хозяина на Node (c0bc564)
• docs(examples): каталог examples/ называет настоящее место примеров — 165 программ в flang/examples (8e02f76)
• proof(self): границы, равенство и развёртка монад — 229 обещаний из 371 доказаны ядром, было 150 из 287 (7c594ac)
• proof(self): завершаемость и распределённость говорят о себе — 273 обещания из 360 доказаны ядром (3d143ad)
• proof(self): анализ завершаемости говорит о себе — 108 обещаний из 168 доказаны ядром (e858273)
• proof(self): дефункционализация и горячая замена — 183 обещания из 273 доказаны ядром вместо 137 из 234 (94c131b)
• proof(self): дефункционализация и горячая замена — 183 обещания из 273 доказаны ядром вместо 137 из 234 (cc881db)
• feat(kernel): целость терма читается фактом, а не только объявленным типом (311d78d)
• proof(self): факт-чекинг и запись доказательства говорят о себе вдвое больше — 121 обещание из 228 доказано ядром (979badb)
• proof(parser): разборщик без беды говорит, что отвечает — 546 обещаний из 922 доказаны ядром вместо 527 из 903 (df87aef)
• proof(sha256): раунд и шаги свёрток доказаны — sha256 47→80, provod 30→49 (0561ff8)
• proof(datetime): даты 5 → 18 доказанных из 44 — охрана обещания списана из тела слово в слово (8cc6f88)
• proof(distributed): у узла 117 доказанных вместо 116 — сторона «не больше» у длины метки (ef2bd53)
• proof(monad-expand): у разворачивания монад 34 доказанных вместо 33 — под охраной равенство пустому списку (2d1be20)
• proof(hotswap): у горячей замены 129 доказанных вместо 125 — сторона «не больше» и равенство терму ветви (cb93bbd)
• proof(zapis): у записи доказательств 125 доказанных вместо 119 — охрана списана из тела дословно (17f0d20)
• proof(setoid): у сетоида 158 доказанных вместо 152 — охрана из тела и сторона «не больше» (b3853e7)
• proof(stdlib): шаг свёртки, вынесенный в обычную функцию, доказал 19 обещаний в четырёх файлах (4336f59)
• proof(bounded): границы 136 → 139 доказанных из 297 — неравенство развёрнуто стороной «не больше» (455e373)
• proof(automaton): доказано 98 обещаний из 102 вместо нуля из пяти (447f0c3)
• proof(self): расснаряжение и сверка фактов — 142 обещания из 305 доказаны ядром вместо 125 (a9ea8ce)
• proof(emit-js/rust/elixir): 19 обещаний трёх печатников доказаны формами, списанными с близнецов (ce2e843)
• proof(self): ведомость и планировщик — доказано 224 → 247 и 318 → 321 (d76ceec)
• proof(parser): 151 обещание разборщика доказано ядром — 526 из 903 вместо 375 из 752 (435de7d)
• proof(kernel): ядро переписывает «элемент N в …» по построению списка — три равенства, проверка ядра чистая (0f1a2e1)
• proof(emit-go): печать в Go — 150 обещаний из 194 доказаны ядром вместо 122 из 194 (2a364f1)
• proof(emit-java): печать в Java — 137 обещаний из 202 доказаны ядром вместо 100 из 200 (ce3135f)
• proof(types): проверка типов — 212 обещаний из 587 доказаны ядром вместо 170 из 585 (cfbfb0f)
• proof(self/emit): «Свободное имя» доказано в обоих файлах — C# 138 из 245, Python 306 из 366 (cc36ac1)
• docs(man): страница руководства догнала двоичный — версия 0.6.2 и ключ предела шагов (c2f5c51)
• proof(stdlib): поле суммы и равенство варианту подняли образцы 15 → 36, вывод ключа 3 → 6, логику 12 → 13, дерево чисел 6 → 7, SCRAM 7 → 9 (03039ac)
• proof(postgres): 56 обещаний драйвера из 121 доказаны ядром — было 18 из 84 (925148c)
• proof(self/emit): в печати C# доказано 137 обещаний из 245 вместо 103, в печати Python — 305 из 366 вместо 285 (2cf0044)
• proof(emit-c): печать C — 291 обещание из 403 доказано ядром вместо 278 из 396 (386c48a)
• proof(interpret): толкователь 163 → 172 доказанных ядром, встроенные формы 136 → 137 (21e0c7e)
• proof(self): failures 159 → 181 обещаний доказано ядром, lsp 100 → 111 (be0b8f0)
• proof(stdlib): четыре ложных обещания der/x509 убраны, доказано der 31→34 из 51, своих x509 17→19 из 34 (c04d2e7)
• fix(stdlib): «Место совпадения» находит пустое совпадение за последним знаком — 57 расхождений из 3600 случайных пар закрыты (7f1d338)
• proof(tls): записи TLS 1.3 — доказанных 115 → 134 из 336 утверждений (91f0af8)
• feat(stdlib): регулярные выражения выражены конечным автоматом — 63 функции с доказанным завершением, миллион построчных решений сошёлся с чужими движками (b4a7a1e)
• proof(base64): решает полнота пути в охране, а не форма записи — 40 из 66 и 38 из 65 держатся (0e1896a)
• proof(hashmap): столбик хеша запирает целость, а не оборванное звено (52be6f9)
• proof(stdlib): шаг свёртки, вынесенный из лямбды, доказывается охраной по ходу — strings 30→41, lists 16→23 (ac18942)
• perf(runtime): область не копирует подграфы ниже отметки — проверка types.flang 14,15 → 6,66 ГиБ и 148 → 118 с (bca43b9)
• perf(runtime): откат области зануляет куски до текущего, а не всю историю арены (e417d92)
• docs(imena): два файла названы по-английски вместо транслита — temp-directory и if-branches-unfold (ca4c790)
• feat(conc): планировщик процессов на C ждёт сеть — шесть поручений соединения исполняются, а не отказывают (7ebaabc)
• proof(aes): «Подстановка» и «Обратная подстановка» доказаны теоремой по свойству — доказанных 99 → 101, сетка 112 → 110 (c2926f1)
• docs(io): граница языка проходит между «решает» и «ждёт», а не между «завершается» и «не завершается» (1449d8b)
• proof(utf8): 38 обещаний из 65 доказаны ядром вместо 18 из 45 (2715b7d)
• proof(base64): 40 обещаний из 66 доказаны ядром вместо 28 из 58 (7a04973)
• proof(sha1): «Шаг байта SHA-1» и начальный свод описаны наравне с SHA-256 — доказано 6 → 18 из 27 (1d0dfc5)
• proof(hmac): шаги свёрток «Начало списка» и «Исключающее или списков» описаны — доказано 4 → 11 из 24 (5d87528)
• proof(sha256): «Шаг байта» говорит о каждом из восьми слов свода — доказано 39 → 45 из 83 (71868fe)
• proof(aes): 19 обещаний доказаны охраной из тела — доказанных в файле 80 → 99 из 231 (e510d4a)
• docs(numbers): после разбора ИЛИ-охраны прибавки нет — зеркало, три оставшиеся охраны и разбор по исходам сравнения замерены (7e307ce)
• proof(datetime): доказанных 5 → 8 из 34 — «ноль печатается буквой Z», «что раньше по мгновению, то раньше и по ответу», «пустая строка даёт минус единицу» (7f43a98)
• proof(x25519): доказанных 14 → 18 из 35 — разложение по разрядам, сдвиг на ноль, нижняя мера «В байты» и умножение на число (624bc47)
• proof(provod): провод несёт 29 обещаний из 63, redis — 24 из 70; ветви «если» и «разбор» взяты дизъюнкцией по условиям пути (8def16d)
• proof(ядро): свёртка над пустым списком переписывается в своё основание (5ef6f3f)
• proof(sqlite): доказано 54 → 96 из 195 — охрана из тела, ветка за веткой (b5b6b71)
• proof(crl): список отзыва — доказанных 120 → 133 из 274 утверждений (f7f2321)
• proof(stdlib): реестр доказан целиком, образцы подняты с пяти обещаний до шестнадцати (cb0d125)
• proof(stdlib): достройка нижних звеньев подняла json 31→42 из 106 и http 26→42 из 114 (a5737ab)
• docs(stdlib): чем заперты обещания sets и hashmap — названо прогоном, а два прежних объяснения опровергнуты (8186500)
• proof(stdlib): «Меньшее» и «Положить» доказаны — 19 из 43 → 22 из 45 в higher-order, 11 из 19 → 12 из 20 в dictionary (32c0560)
• proof(numbers): «Целая часть» доказана обо всех входах, доказанных утверждений в файле 7 → 11 из 32 (cf2930b)
• proof(kdf): нижнее звено «Дописать номер» и край «Витков вывода» доказаны — вместе с ввозом 44 → 46 доказанных из 103 (4615350)
• proof(numtree): краевые случаи дерева доказаны — обещаний 8 → 12, доказано 2 → 6 (33a7f42)
• proof(logic): законы отрицания, конъюнкции и импликации доказаны ядром — обещаний 7 → 15, доказано 4 → 12 (3b25a06)
• proof(stdlib): охрана тела и равенство литералу подняли lists 11→16, hashmap 11→15 (2533f18)
• proof(stdlib): охрана из тела доказала 9 обещаний postgres и 3 redis (8b113dc)
• proof(lists): «до нуля промежуток пуст» отделено от «предел стоит последним» — 12 доказанных из 40 (0099c38)
• proof(optional): «Возможно» доказано равенством варианту — 7 обещаний из 14 против 2 из 12 (b96899e)
• proof(result): все 15 обещаний «Результата» доказаны обо всех входах, сетки не осталось (79dd2a4)
• proof(x509): своих доказанных обещаний X.509 6 → 17 из 34 — имена и сроки доказаны обо всех входах (a247a18)
• proof(der): доказанных обещаний DER 15 → 31 из 46 — оборванная цепочка обещаний сомкнута снизу (36ae2d2)
• proof(stdlib): множества 4→5 и списки строк 5→6 доказанных, словарь остался 11 (8457190)
• proof(utf8): 18 обещаний из 45 — «негодная точка даёт знак замены целиком» доказано по телу (9f072cc)
• proof(base64): 28 обещаний из 58 — «прописная буква даёт свой номер от нуля» доказано по телу (f0cb47a)
• proof(провод): доказано 14 → 16 из 45 — «Целое из текста» зеркалит оба если тела (1ec898b)
• proof(провод): доказано 8 → 14 из 44 — оговорка обещания дословно повторяет вложенное условие тела (95635ef)
• proof(sqlite): доказано 37 → 47 из 151 утверждения, и потеря строк на многостраничной базе теперь под обещанием (49442dd)
• proof(ecdsa): длины разрядов, постоянные кривой и границы витков доказаны (ddddfe9)
• proof(rsa): переносу, битам показателя и обеим ветвям витка степени дано доказательство (7b0397a)
• proof(utf8): 17 обещаний из 44 доказаны ядром вместо 12 из 43 (78ad87b)
• proof(base64): 27 обещаний из 57 доказаны ядром вместо 17 из 47 (898689a)
• proof(stdlib): в «Строках» доказано 30 утверждений вместо 7, в «Дереве» 8 вместо 3 (e041f8a)
• proof(self): 7 обещаний доказаны в obligations.flang — «Обязательства функции», «Свести теорему» и ещё пять (3b78c49)
• proof(tls): доказанных 15 → 21 из 69 утверждений (9813346)
• proof(crl): доказанных 56 → 59 из 190 утверждений (ebcf4cd)
• feat(krypto): вывод ключей TLS 1.3, свой ClientHello и расшифровка первой закрытой записи сервера (9cb4505)
• proof(stdlib): разложение конъюнкций закрыло 16 обещаний — sha256 26→40 из 81, numbers 5→7 из 28 (451966f)
• feat(aes): 2 вектора FIPS-197 расшифровываются в исходный блок, и все десять обратных раундов сходятся со следом стандарта (f97eb6f)
• fix(crl): серийный номер печатается без ведущего нуля DER — 7 номеров из 7 сошлись с openssl crl -text (e13d7cb)
• feat(sqlite): драйвер собирает базу с нуля — свой файл на 19 страниц настоящая sqlite3 читает целиком (a83196e)
• proof(http): составные обещания разложены — доказано 26 из 104 в HTTP, 15 из 78 в Redis, 18 из 117 в Postgres (242b0ed)
• proof(json): доказано 31 утверждение из 97 вместо 19 из 60 — составные обещания разложены на именованные части (2501f53)
• perf(zamykanie): «только» сужает работу проверяющего — tags.flang на 29 % быстрее при той же программе (339f1be)
• feat(kernel): охрана цели «если ⟨границы⟩ то ⟨суть⟩ иначе да» даёт ядру конечность терма — как давала оговорка дизъюнкцией (15c3f07)
• proof(self): 187 обещаний доказаны в parser.flang и monad.flang — проверка проходит, 17,3 и 29,8 ГиБ пика (f2d3c8a)
• perf(runtime): обмер области обрывается доказанной оценкой — tags.flang считается за 13,8 с вместо 16,4 (9a107d9)
• proof(strings): три дыры ядра названы поимённо — теоремами и разложением конъюнкций в строках, списках и списках строк не закрывается ни одно обещание (6eacdc0)
• feat(kernel): правило «начинается с» читает точный текст терма и приставку приставки (fce9805)
• refactor(biblioteka): 35 столкнувшихся имён обещаний разведены — теорема теперь находит ровно одно постусловие (221445f)
• test(krypto): удвоение и сложение точек краснеют на обычной проверке, а не только на полном прогоне (969de9a)
• proof(http): провод несёт 8 обещаний из 42 без единой теоремы, http — 15 из 71; тела-вызовы перебраны сплошь (fa321ca)
• feat(krypto): подпись ECDSA на P-256 проверяется — сверено с openssl на настоящем ключе (34efcd8)
• proof(biblioteka): названо поимённо, чего не хватает трёмстам недоказанным обещаниям (a8e2250)
• fix(sqlite): база крупнее одной страницы читается целиком, а не молчит (cb57058)
• feat(reestr): реестр пакетов — поиск по имени, диапазоны версий, разрешение зависимостей (13ba286)
• feat(krypto): проверка подписи RSA-2048, AES-256, режим CBC и записи TLS 1.3 — сверено с openssl и NIST (314d373)
• proof: 987 обещаний о поведении написаны в 27 файлах, 1934 из них доказаны ядром (1ae606b)
• perf(runtime): сравнение имён отсеивается по двум первым байтам — strcmp ушёл из верхушки профиля (3ea57bd)
• feat(io): словарь поручений 18 → 20 — удалить файл, завести временный каталог (5d93a1b)
• feat(cli): предел шагов проверяющего задаётся ключом — json.flang судится обычным двоичным (cbdda00)
• proof(biblioteka): названо поимённо, чего не хватает 300 недоказанным обещаниям (0b52b8d)
• fix(sqlite): база крупнее одной страницы читается целиком, а не молчит (91cdf75)
• feat(reestr): реестр пакетов — поиск по имени, диапазоны версий, разрешение зависимостей (fd8e22c)
• feat(krypto): проверка подписи RSA-2048, AES-256, режим CBC и записи TLS 1.3 — сверено с openssl и NIST (35ccb96)
• Проверка отзыва сертификата: разбор CRL по RFC 5280 (1dbd3a9)
• AES: дешифратор блока и режим CBC с набивкой PKCS#7 (48fdc58)
• Сравнение имён без похода в libc: отсев по двум байтам до strcmp (b7f3bd5)
• Словарь ввода-вывода: «Удалить файл» и «Завести временный каталог» — 18 поручений стало 20 (ea25b46)
• Обещания для flang/self/emit-go и flang/self/emit-python (7dfce68)
• Ядро: десятое правило «начало по построению» + подделка и честная половина (9b109cc)
• check: ключ --предел-шагов / --step-limit — предел шагов проверяющего задаётся при запуске (dd5fe0f)
• Обещания о поведении для функций, у которых их не было (0bc9378)
• обещания не переживают заглушку: усилены пятнадцать пустых (69ba2b3)
• Образцы: замена по образцу — то, на чём вставала markdown.mjs (acafa36)
• обещания четырём файлам доли d-7: 122 постусловия, 97 доказано ядром (7849a81)
• обещания о поведении: 120 постусловий в восьми файлах доли d-10, 118 доказано ядром (f80dffa)
• обещания о поведении: 7 файлов доли d-4, 133 обещания, 127 доказано ядром (d592887)
• обещания о поведении: четыре файла доли d-5 (521e3bc)
• обещания: сращивание, redis-план, json, узел замера (8568743)
• Жаргон: внутренние слова заменены словами читателя в одиннадцати поверхностях (9784804)
• обещания: ещё 20 по семи файлам (073eb9d)
• парсер FTS: 31 обещание (dd03afd)
• x25519: 7 обещаний (464223c)
• Ствол зелёный: сняты шесть утверждений, зовущих невидимые ввозящему имена, парсер ввозится ядром целиком (936f5c6)
• Сборка выпуска на flang: сняты последние три файла кластера (c1cd565)
• Досчитан перебор по higher-order: 23 035 индукционных теорем, побед ноль (98577c6)
• Замер доказуемости datetime, scram и kdf: почему теорема их не берёт (f3bc700)
• Напечатанные модули узла перепечатаны: пропажа узла и подхват процессов доехали до дерева (f4127e2)
• Утверждения для ввода-вывода, записи доказательства и трёх файлов отказов (ad03489)
• Замер: попытка доказать 62 обещания четырёх модулей теоремами дала ноль (626a2ed)
• AES-GCM на flang: умножение в GF(2^128), GHASH, шифрование с тегом и расшифровка с проверкой тега (4943015)
• Подсветка сайта: сверка «знак в знак» переехала на flang (79378e6)
• парсер: утверждения ещё у 8 функций — вид узла при опознанном слове (dee1f9a)
• категорная поверхность: 141 утверждение «обеспечивает» в восьми файлах (f362e35)
• Утверждения вычислителя и горячей замены: +110 функций (6ebb7c8)
• Сайт: внести библиотеку образцов из j-1 (31 функция, завершение доказано) (ca60837)
• Проверка типов: утверждения ещё у 25 функций укладки входа (2a74fac)
• redis: 61 обещание прогнано теоремами — прибавка ноль, названо седьмое звено (97cd403)
• provod: все 31 обещание прогнаны теоремами — прибавка ноль, шесть звеньев названы поимённо (bd4f7c8)
• теги: ещё шесть утверждений и снятие чужой помехи проверке (123db85)
• оракулы: добить остатки — 17 утверждений, четыре файла закрыты целиком (c8f3c01)
• парсер: утверждения ещё у 15 функций — поверхность разборщика и узлы преобразования (6e04861)
• emit-c: утверждения ещё для 102 функций печати в C (43dc64c)
• утверждения пяти файлов: множества, обязательства, частичный порядок, сетка, теги (b76ed7c)
• оракул категорий: ещё 37 утверждений, файл закрыт до 84 из 88 (bd2707b)
• Проверка типов: утверждения ещё у 128 функций (182f4ff)
• Библиотека: сопоставление по образцу вместо регулярных выражений (01dd3af)
• Доказательство: семь теорем к крипто-модулям (aes, der, x25519, x509) (370baea)
• оракул категорий: 45 утверждений «обеспечивает» (1914b70)
• парсер: утверждения ещё у 57 функций — накопленные списки сборок и запись в сборке документа (adfa138)
• оракулы: 121 утверждение «обеспечивает» в четырёх файлах (748fcad)
• Назван прогоном отказ, из-за которого посылка «Искать» остаётся на сетке (ca930b8)
• парсер: утверждения «обеспечивает» ещё у 111 функций разборщика (37504ae)
• Числа: замер попытки доказать обещания теоремами — прибавка ноль (6d4cc47)
• http: замер, чего недостаёт 56 недоказанным обещаниям (344f737)
• Четырнадцатое имя правила сведения вписано в закрытый список сверщика (6e1299e)
• sha256 и base64: составные обещания разложены на именованные части (e09ad00)
• Строки: теорема на «разложить на знаки и склеить обратно — ответ тот же» (5430596)
• Снят flang/test/lsp.test.mjs: он говорил с сервером, которого больше нет (b84b017)
• Утверждения о поведении: 135 функций в failures.flang, 111 в bounded.flang (78ed7da)
• печать в C: ещё 17 утверждений, всего 210 функций с утверждением (4aa90cc)
• Утверждения о поведении: 157 функций (proof-initial.flang 86, setoid.flang 71), строк «обеспечивает» 184 (9213fb9)
• Языковой сервер: снято утверждение у «Уровня» — довод о цене живой; у «Вида объявления» поправлен протухший довод (сторож класса удалён) (88b8c05)
• self/conc и self/distributed: утверждения о поведении ещё 144 функциям (85e5da4)
• self/proofterm: утверждения о поведении у 138 функций записи доказательства (a5e0c7d)
• утверждения о поведении: 330 функций в трёх файлах самоприменения (a7a74c8)
• печать в C: утверждения о поведении для 193 функций (8168523)
• Парсер: утверждения «обеспечивает» для 155 функций из 629 (271879c)
• ведомость: утверждения «обеспечивает» у 253 функций flang/self/proof.flang (a7a52e3)
• Утверждения о поведении: 78 функций в proof-initial.flang, 50 в setoid.flang (0be39b4)
• Путь установки: статическая половина — сторожем на flang, прогон снят (72451b3)
• Проверка типов: утверждения «обеспечивает» у 232 функций из 626 (e625c59)
• Вычислитель: утверждения о поведении у 158 функций (ea59db4)
• Парсер: утверждения «обеспечивает» для 132 функций (3e35c3f)
• self/conc: утверждения о поведении для 112 функций планировщика (c122246)
• Словарь хешем и Провод: семь обещаний сняты ядром (a495c7e)
• Разбор DER и чтение сертификата X.509 своими руками (8186fc5)
• X25519: обмен ключами на самом flang, сверено с векторами RFC 7748 (83a1608)
• AES-128 и режим CTR: своя криптография вместо чужой (a9802c6)
• Утверждения «обеспечивает» в flang/self/emit-java.flang (dc7d6b1)
• Печать в C#: утверждения «обеспечивает» для 244 функций из 348 (834e47a)
• postgres.flang: составные обещания разбиты на именованные части — ядро закрыло три (2a77eef)
• self/factcheck: утверждения доведены до 106 функций (133 утверждения) (3a76695)
• Второй драйвер базы: чтение файла SQLite 3 (e839d8a)
• Ещё 55 утверждений о поведении в emit-python: всего 162 функции (64922b8)
• Утверждения «обеспечивает» в self-файлах: builtins.flang — 98 функций из 98, monad-expand.flang — 87 из 96, всего 185 (41e90c6)
• Печать в Go: ещё 25 утверждений — покрыто 126 функций (1f02094)
• Утверждения о поведении в flang/self/totality.flang: 115 функций (d86e794)
• Печать в JS: утверждения о поведении для 149 функций emit-js.flang (c5d5a96)
• self/factcheck: ещё 31 функция с утверждениями (43 утверждения) (03d5f3f)
• Утверждения «обеспечивает» в печати в Elixir: 130 функций из 382 (c8fff3b)
• Печать в Go: утверждения о поведении для 101 функции (28596c1)
• self/factcheck: утверждения о поведении для 37 функций (42 утверждения) (fc1e046)
• Утверждения о поведении для 107 функций emit-python (c47f1dd)
• self/emit-rust: утверждения о поведении для 113 функций (09c1256)
• Утверждения о поведении для flang/self/builtins.flang: 96 функций получили «обеспечивает» (5718917)
• self/defunc: утверждения о поведении для 120 функций (132 утверждения) (3671b6d)
• Сторож подделок ядра снова зелёный: два довода в ядре приведены к заголовку, две подделки вписаны под надзор (4387a8f)
• Счёт замкнутых частей переехал внутрь правила тождества: отдельным ходом он стоил datetime.flang всей ведомости (5c0e3bb)
• Теги программы: 8 обещаний, и ещё одно лексеру — все доказаны обо всех входах (27c9f30)
• Ядро выписывает ходы сведения, и сверщик их проигрывает: круг замкнулся на неотрицательности (f47d7f6)
• Печать в C кладёт в вывод движок процессов: два процесса живут без единой строки руками (9b4f530)
• Сторож подделок снова зелёный: пятый заголовок довода вписан, две беспризорные подделки взяты под надзор (ac8dcce)
• Ядро считает замкнутые части равенства; застава минус нуля закрыла дыру, через которую тождество доказывало ложь (a4df893)
• Три пары тел ядра были дословными копиями друг друга: слиты, вердикты те же (72b2ce1)
• Предел шагов 1 000 000 000 → 4 000 000 000: ведомость json.flang считается (659a297)
• Седьмой ход называет источник: «доказано при условии» (f732c0c)
• Ядро получило нижнюю границу произведения; улика закрыта, и только в паре с зеркалом (d15f93b)
• Сторож доверия ядру переписан на flang: числа сошлись в трёх состояниях, .mjs снят (000c016)
• ядро: посылка индукции телу-«если» по отрезку «нат» без теоремы (2365e95)
• Развести три имени драйвера Redis и научить сторож на flang их видеть (a9ed3c0)
• Составные цели строк и utf8 разняты на половины: доказано 15 → 17, обе прибавки ПУСТЫ (18fb626)
• по свойству перемерено отдельной пробой, а не только файлом дерева (690e186)
• Сторож заведён ярлыком, и в списке умений — только то, за чем стоит прогон (129eb18)
• Файл противоречил сам себе про по свойству — снято прогоном (9636484)
• Ядро: правило 9 «модус поненс по охране» + перепечатка семени (e419dd7)
• Числа переписи и порчи — прогоном, а не по памяти (7c1e3f5)
• Описание догнало ядро: 28 умений названы словами, сторож зелёный (a2aeb01)
• Список умений в одном месте и сторож на расхождение — пока КРАСНЫЙ (988086c)
• Закрытый список правил сверщика равен набору ядра: не восемь, а тринадцать, и это сверяется прогоном (3315cf0)
• Улики: ещё пять умений — седьмое и восьмое правила ядра (c9de3a3)
• Улики: восемнадцать умений ядра, снятых прогоном (0d99598)
• Библиотека: ложное обещание «Противоположного» на бесконечности, +3 доказанных в result.flang (c9a7397)
• Опрос хозяина на C поимённо и двое процессов на своём движке: 6 поручений из 18 исполняются, 12 отказывают по имени, молчания нет (e373a9e)
• Компилятор перепечатан после пяти веток: обе сверки, дешёвая и побайтовая, зелёные (9e2a2ac)
• Главный пробел ядра для JSON назван в файле: часть значения в СПИСКЕ своего типа частью не считается (955615f)
• Обещания у core/json.flang: было ноль, стало пятнадцать, доказано три (76a699f)
• Малый сводитель отличает свою слабость от чужой ошибки (ca86349)
• Две составные цели utf8 разняты на половины: доказано 7 → 10, из трёх новых содержательны две (96b9ff2)
• Второй, малый сводитель отвечает о тех же утверждениях, что и ядро (026a44d)
• Словарь деревом: «у листа приоритета нет, а у узла он — записанный в узле» доказано индукцией (815c00c)
• Замер по json.flang и base64.flang: теоремы не прибавили ничего, и это записано в файлах (7d5fc23)
• Теоремы при обещаниях json.flang и base64.flang: оставлены только принятые ядром (44bd829)
• Черновик: теоремы при обещаниях json.flang и base64.flang (fbee7b1)
• Спецификация категорной поверхности без запрещённого слова: снятие объявления названо своими словами (31011c5)
• Сведение проигрывается по шагам: семь первичных ходов, и сверщик их проверяет (01339b9)
• Две теоремы при обещаниях http.flang: доказано 12 → 14 (6af3738)
• Четыре обещания SCRAM несёт теорема, а не рантайм: длины солёного пароля, ключа клиента и серверного ключа и связь хранимого ключа со сводом (ea12f7f)
• Проза о печати плана догнала прогон: восемь целей, два законных исхода, сверка и подделка названы (beab7fb)
• Семь целей печати ОТКАЗЫВАЮТ на объявлении «план» кодом FLANG_PLAN_UNSUPPORTED, а не забывают его молча; точка раскрутки перепечатана (9c2b95e)
• Седьмое действие вернулось в язык: словарь «Действие» приписывается семью вариантами там, где написано «поручить» (fe54768)
• Лексер компилятора: 87 обещаний, все доказаны обо всех входах (d7e1eee)
• Восемь обещаний хеш-слоя доказаны теоремой, а не сеткой (d625f78)
• Ядро: допущения приводятся к одному виду — зеркало порядка (5a86c99)
• Ссылка сверяется ПРИ ПОЛУЧЕНИИ: собеседник называет и имя, и то, что принимает, чеканка стоит за сверкой, и имя чужого вида ссылкой не становится — отказа при доставке нет вовсе; подделка с грузом чужого типа отвергнута FLANG_TYPE (5eadabd)
• Словарь хешем: «чего в словаре нет, за то отдаётся запасное» доказано теоремой (05fe02f)
• Прогонщик на негодном октете отказывает, а не молчит: семь целей сведены байт в байт (dac469e)
• Замер общего у двух драйверов: 12 функций «Провода» из 31, остальные 19 про двоичную рамку; заметка о недостижимом случае (504e491)
• Вторая база: драйвер Redis (RESP2) и план, поговоривший с настоящим сервером по паролю (b990c86)
• Замер печати плана по восьми целям снят заново: js больше не падает и печатает план, семь молчат по-прежнему (0a9fd22)
• Разбор входа SASL: снят второй, недостижимый набор случаев — постусловие «Разобрать вход» сошлось, файл снова проходит проверку (d2aa28b)

Ещё 1084 правки языка снаружи не меняют.

0.6.2 — 22 августа 2026

• Формула на 0.6.2 и запись о выпуске: чинится установка через Homebrew (1201f5a)
• Компилятор перепечатан под 0.6.2 (32d3c4b)
• Упаковка выпуска чинится буквой X: без неё каталог runtime-c приезжал без права входа и brew install падал у всех (54a5ac4)
• Версия 0.6.2 (49bf68b)
• Разведка ввозов разбирает шапку, а не весь файл: память −24 %, время −5 % (b7a7b86)
• Принцип свёртки говорит теперь и о пройденном куске списка: доказано 197 → 199, потеряно ноль (17b2c26)
• «https» у поручения «Запросить» работает: шифрование берётся поручением внешнему хозяину, а не своим кодом (d44e4c2)
• У строки одна мера и там, где строка — октеты: поиск ходит по границам знаков, счёт сведён с нарезкой, склейка отказывает на слипающемся стыке (f11343e)
• Две рукописные копии сличения списков сняты, три устаревшие ссылки на снятый запрет исправлены (2eae04b)

Ещё 4 правки языка снаружи не меняют.

0.6.1 — 22 августа 2026

• Формула Homebrew переведена на 0.6.1: sha256 посчитан на архиве выпуска (9683d80)
• Компилятор перепечатан под 0.6.1 после шести веток: дешёвая сверка входов зелёная (643bed2)
• Версия 0.6.1 и запись о выпуске (1b4232b)
• Компилятор перепечатан после четырёх веток: правила «или» и фильтра доехали до собранного, отпечаток входов снят (9efb373)
• Двоичный говорит по протоколу помощника: flang --mcp-mode, и три вердикта уходят порознь (15342ea)
• Точка раскрутки перепечатана: тридцать шесть проверок ядра уехали в семя (ba2207f)
• Числа сведены с собранным двоичным: 13 894 920 октетов, 31 с, 7,3 ГиБ (24d9bb8)
• Точка раскрутки перепечатана после правки порядка строк записи (a9fb259)
• Точка раскрутки перепечатана: словарь на восемнадцать поручений, оба хозяина на C, отказ FLANG_IO_NOT_TEXT (48d6a84)
• Прибавка от обоих правил названа числом в самом ядре: +2 и +2 на шести файлах библиотеки, парным замером (1a95824)
• Прогон подделок спрашивает сверщика о всех программах каталога примеров, а не об одной (7857320)
• Сверщик читает вариант, написанный голым словом, и знает конструкторы встроенного списка (f70597f)
• Заголовок случая в записи встал перед своими шагами: «добавить» дописывает в конец (5fa0001)
• Числа замера в ADR-0006, SPEC и примере: три порчи, четыре размера, цена памяти (3fdaa91)
• Нулевой октет вернулся в законный текст: отказ теперь только на неправильном UTF-8 (a45e34a)
• Точка раскрутки перепечатана: семя несёт запись доказательства и ключ --записать (ca25911)
• Долги записи и сверщика названы прямо: сведение, вторая командная строка, один шаг на строку (aaa8a35)
• Из 49 сведённых обещаний ядра остались 36: подмену тела пережили тринадцать (9b64462)
• Точка раскрутки перепечатана под два новых правила ядра; сверка --check совпала байт в байт (cb31c94)
• man flang описывает ключ --записать: доказательство кладётся в файл и сверяется отдельной программой (a34fbb4)
• Счёт постусловий не считает пояснения: строка, начатая двумя косыми, не объявление (5d96bbc)
• Шапка сверщика перечисляет все девять проверок, а не шесть (c335b01)
• Закрытие цели считается по случаям, а не в среднем по теореме (08b78ee)
• Сверщик спрашивает хозяина утверждения и у тех, при которых теоремы нет (25ece3f)
• Имя «Строка шага» разошлось с отчётом о доказательствах: у записи оно своё (0624a87)
• Запись обязана говорить обо всей программе: счёт постусловий сверяется с исходником (a2bf55e)
• Сверщик сличает утверждаемое теоремой с обещанным постусловием (6d091d3)
• Сверщик получил закрытый список правил сведения и проверку полноты записи (3c44eb5)
• Доказательство стало предметом: ядро записывает свой терм в файл, сверщик на flang сверяет его с исходником (56488e5)
• «Ответить в соединение» перестало рвать содержимое strlen'ом: длина берётся у значения, нетекст отвергается (9632acf)
• Ядро получило разбор случаев по внутреннему условию цели и правило несовместимых допущений; при обоих стоят подделки (a443b7c)
• Ядро доказательства обещает о себе: 49 постусловий, все сведены ядром (21c7180)
• Пример «Двоичный файл туда и обратно», ADR-0006 и словарь в SPEC: восемнадцать поручений (5b62c16)
• Октетная пара у файлов: словарь, оба хозяина на C; текстовая пара на нетексте отказывает вместо молчания (bcf4c69)

Ещё 16 правок языка снаружи не меняют.

0.6.0 — 22 августа 2026

• Формула Homebrew переведена на 0.6.0: ссылка на тег v0.6.0, sha256 посчитан на архиве выпуска (55292de)
• Перевод компилятора на C перепечатан под 0.6.0: потолок шагов внутри поднят до миллиарда, два захода подряд дали одно и то же (a722581)
• Ядро берёт цель «А и притом Б»: половина «условие ложно» есть ложь (4522d7f)
• Ведомость пустоты заведена и сошлась: 93 доказанных по 18 файлам библиотеки разложены по четырём кучам (d22c94c)
• Семя перепечатано: ядро в двоичном опровергает границу над числом, и улика задания закрыта (0cfcf7d)
• Пустота закрыта там, где ядру хватило правил: logic ×2, numbers, strings; при стороже заведён показ порчи (32f3979)
• Две ложные границы карты ядра оговорены: К2 и П3 были ложны на «не числе», доказанного при этом не потеряно (71d1d78)
• Перевод компилятора на C пересчитан после слияния двадцати веток: два захода подряд дали одно и то же, 7 файлов, 26 110 965 байт (ce6e760)
• Ядро научилось ОПРОВЕРГАТЬ границу над числом: контрпример «не число» называет оно само (0b3db25)
• Точка раскрутки перепечатана: область на виток батута доехала в семя (a00ac8d)
• Сторож пустоты: разбор ведомости и чтение исходника на flang; «Знак» перестал говорить о подписи (2a9f350)
• Числа в пояснении к области витка — по парному замеру, а не по прикидке (37f8ad9)
• Область на виток батута: хвостовая рекурсия перестала копить арену (202afd3)
• Старое имя дочищено в контрактах Провода (d9e7e3e)
• Столкновение имён разведено: «Цифра числом» Провода зовётся «Цифра провода», у strings.flang имя остаётся своим (033b491)
• Поломки от слияния сведены: вторая копия SASL снята, «Целая часть протокола» объявлена в плане, долг сращивания пересчитан (cce8fff)
• Семя возвращено к стволу перед перепечаткой (295522f)
• Семя перепечатано после снятия задвоенной функции и сведения со стволом (9fce394)
• Путь в пояснении примера записан латиницей целиком: половина имени файла была кириллицей и команда из шапки не работала (a77ade3)
• Семя перепечатано: ядро в двоичном читает оговорку «пока это число» (5e444b8)
• Точка раскрутки перепечатана: починка цели «js» доехала в семя, и из семени собирается компилятор, который её знает (416618d)
• Оговорка в utf8: тело «Досыпать байты» совпадает с «Соединить списки» с точностью до имён доводов, и счёт копий по телам эту пару не ловит (007bb73)
• Провенанс векторов записан в сами модули: чем и когда сверено (5b01c42)
• Числа в шапке postgres выправлены по замеру: 86 функций, 3 файла замыкания, 18 замечаний на снятой строке ввоза (8017570)
• Пример «библиотечное API» снова собирается: в списке только не хватало имён, которые зовёт контракт ввезённой функции (aae2d38)
• Вход по scram-sha-256 в настоящую базу СОСТОЯЛСЯ, и журнал прогона записан в шапку (a8d6bc2)
• План входа: после запроса вводится состояние «Послали запрос» (ddff135)
• Дизъюнкция в допущении разбирается СЛУЧАЯМИ: цель сводится дважды, при левом и при правом дизъюнкте порознь, и принимается только когда сошлись оба (06d117e)
• Библиотека сводится в одну программу: девять вернувшихся столкновений разведены, а мерой стал прогон, а не абзац (80205ee)
• Страница про базы говорит про два файла, а не про один, и числа «Провода» считаются (fd7d03a)
• План входа: проверочная роль probnik1 с одним витком, и упор назван памятью, а не временем (bf25259)
• Фронтенд поехал: цель «js» научилась печатать план, страница осталась без единой строки JavaScript, стенд написан на flang (56b7d47)
• Ссылка пересылается письмом, и по ней приходит ответ: работник отвечает тому, чьего имени в его коде нет (e749515)
• Слой доказательств на JavaScript снят: 4958 строк, живого потребителя не было (ec375d8)
• Справка доехала до семени: пересборка положила её туда, куда прямое копирование не легло (2b6e184)
• Шапки драйвера и плана входа приведены к тому, что есть на самом деле (fe44f6b)
• Имя с провода, назвавшее процесс другого вида, отказывает ОТПРАВИТЕЛЮ по имени: FLANG_PROCESS_ACCEPTS вместо тихой смерти получателя (1d02aaa)
• Одинокая низкая половина считалась у C# нулём знаков: «длина» и «разложить на символы» расходились ВНУТРИ одной цели, 4 входа из 12 — теперь 0 (4508d18)
• Вход по scram: четыре RFC-2202 вектора, груз SASL в вести и октетная труба у плана входа (7587800)
• Ядро читает оговорку «пока это число»: правило и четыре подделки при нём (9f655a5)
• Общая половина драйвера вынута в «Провод»: из 83 функций про PostgreSQL только 39 (f603430)
• Смерть соседнего узла пережита на 8 целях из 8, и по дороге найдена дыра у rust и c: подхваченному процессу негде было завести состояние (0157027)
• Модуль зовёт соседа, а сторож смотрит на всё дерево, а не на один вход (c456b6b)
• Отказы ядра доказательств названы поимённо: 13 из 13, и у каждого сказано, чинится он теоремой или упирается в предел языка (bd0ece0)
• Ввозы узла выровнены под новый ствол e21199e3, и две записи базы знаний о пропаже узла (dff71d4)
• Снята вторая копия «Мера склейки», оставленная моим слиянием (d2f5379)
• Три написанных вручную сличения сняты, и одно из них было неверным (26b206c)
• Сохранение множества отделено от сохранения меры: на одном теле мера доказывается индукцией, множество остаётся сеткой (bf14a43)
• Пропажа узла доезжает до надзора на всех восьми целях, прогоном подтверждена на двух (fc8f4ec)
• Карта целей написана: 47 клеток вида цели с вердиктом и дословным отказом ядра, перепись библиотеки считается командой (30f0d4c)
• Сторож подделок сверяет список с каталогом в обе стороны — и нашёл четыре подделки, которые не проверялись ничем (ec56299)
• Надзор переживает смерть соседнего узла: работа убитого узла подхвачена, подтверждено 2 против 1 (30c6072)
• Последняя копия «Целой части» снята: postgres-plan снова доходит до настоящей базы (809311e)
• Клетки карты целей заведены уликами: 30 видов цели прогнаны ведомостью, отказы ядра сняты дословно (24a8195)
• Разговор с PostgreSQL идёт по настоящему проводу, и страница говорит это прогоном; печать плана обещана наизнанку (392676c)
• Улика ДО числом: смерть соседнего узла надзор сегодня не замечает — всего 13, подтверждено 1 (25fd27a)
• Равенство в теле функции разрешено: запрет держал не цену, а одну запись, и спека требовала обратного (730210d)
• Надзор узла возвращён в напечатанный узел в четвёртый раз: с ним узел с объявленным деревом надзора вообще не поднимался (ed90e27)
• Возвращён надзор узла: третья работа, потерянная слиянием, а не коммитом (7ab1393)
• Сторож кодов зелен: две спецификации перестали обещать несуществующий код, у снятых переменных завёлся свой род (f92c4d9)
• Возвращён надзор узла: третья работа, потерянная слиянием, а не коммитом (f7ce5b1)
• Категорная поверхность переписана по прогону нового судьи, и девять расхождений дорожки новичка закрыты (65fa1b1)
• Веер сведён в одну функцию и справка очищена от внутренних слов (2289c06)
• Семя перепечатано на сведённом дереве: судья категорных законов, 166 утверждений библиотеки и поднятый потолок шагов в одном двоичном (0446d33)
• Потолок шагов вычислителя поднят впятеро: был съеден под ноль — 200 000 001 виток из 200 000 000 (d49c9df)
• Пробел назван ключами разбора, а сторож состава правил научен второй стороне долга — семя НЕ перепечатано (3e0d540)
• Возвращено правило доказательства о соседних парах, потерянное при чужом сведении: в ядре снова восемь правил (4469811)
• Судья категорных законов вшит в двоичный: подделка отвергается, отчёт называет размер сетки (8557d80)
• Возвращён разбор SASL, потерянный при чужом сведении: план SCRAM снова зовёт существующие функции (c1ff756)
• Семя перепечатано на сведённом дереве: индукция по строке и ствол в одном двоичном, обе подделки правила отвергнуты (e98d02e)
• http: оговорка о числе при строчном коде — без неё утверждение ложно на не числе (f5d20e8)
• Семя перепечатано: слияние ствола потеряло принцип индукции по строке (8701abb)
• Семя перепечатано после догона ствола и сошлось: 7 файлов, 24 684 403 байта (07dc33e)
• Три факта о длине строки заведены, и они дали три утверждения: узким местом был не факт, а то, что мерой длины пользовались два правила ядра из шести (4649484)
• Оснастка перестала звать удалённый компилятор: 38 зовов node flang/bin/flang.mjs в 28 файлах переведены на bootstrap/flang, три скрипта уведены из запрещённого /tmp (8a15ff2)
• Цена утверждений сбита там, где она была настоящей: снят пересчёт и три даровых с вызовами, http переписан на меньшее число действий (eed48b8)
• Слияние поправлено: postgres.flang взят целиком со стороны ветки — ввозы были, а тела остались (d46ca1f)
• sha256: пересчёт следующего слова в постусловии раунда снят — 2197 мс из 12763 замерено чередованием (0c5b155)
• Печать больше не отсылает к удалённому: вместо «инструментария на Node» названы setoid.flang и setoid-oracle.flang и сказано, что их не запускает ничто (bb81144)
• Числа в SPEC слоя доказательств догнали дерево (fa4d9a8)
• Ярлык proof:search снят обратно: его файл удалён намеренно, я вернул строку слиянием по ошибке (5ac835a)
• Точка раскрутки перепечатана под правку справки, второе поколение сошлось: 7 файлов, 24 627 498 байт (4d77236)
• Комментарий у «Досыпать байты» больше не ссылается на мёртвый довод (2da3eb8)
• Ширину знака в байтах называет «UTF-8», а разбор протокола её больше не считает (3852f1f)
• C: приставка внешних имён программы обходит занятое так же, как имя файла (223100e)
• Печать перестала выпускать непосуждённое молча: 41 программа из 951 печаталась кодом 0, теперь код 3 с названным пробелом (9f255bb)
• Третья копия разложения кодовой точки в байты снята — и она давно лгала (75edd9e)
• Три точные меры длины у строки: склейка, разложение, знак — плюс восемь доказанных (e15e519)
• Охрана делает утверждение о дереве поиска истинным, а ядро научено брать её фактом: конъюнкт из охраны берётся, дизъюнкт — нет (0c4f9b5)
• Проверка замкнутости цели встала на прямой шаг «по примеру», а не только на ветвь индукции (82312ae)
• занятые слова цели больше не доезжают до напечатанного кода (4efe982)
• Прогон враждебными входами: одно моё утверждение оказалось ложным, восемнадцать чужих границ sha256 тоже; все починены оговоркой (382330c)
• База знаний: три стены постусловия сняты, даровость вырождается на постоянной функции, девять обвалов на частичных формах (51046c5)
• lists.flang восстановлен: моё сведение взяло сторону, не разбиравшуюся вовсе — 72 примера снова проходят (8c7aaf9)
• У строки появился принцип индукции, и он закрыл одно утверждение, а не сотню (c14cd74)
• http: тридцать три утверждения о разборе запроса, заголовках, чанках и печати (544dd7a)
• postgres: двадцать пять утверждений о вестях, полях и разборе целых (75315ff)
• Пять немых функций заговорили: разбор суммы в постусловии работает, и стена о проекциях снята (8b29e0b)
• sha256 и json: сорок семь утверждений о ходах, разметке и разборе; липкость беды записана явно (9b8dff6)
• Витрина категорной поверхности: черновик убран, граница названа числами, 28 мёртвых путей сняты, жаргон 19+54 → 0 (751eeb8)
• base64: тринадцать утверждений о ходах кодирования и четыре ложных утверждения о шестёрках исправлены оговоркой о конечности (6d18434)
• Утверждения о проекциях, опциях и итогах: поле варианта и сравнение сумм читаются в постусловии (d80e070)
• Промежуточный факт лёг в ядро и закрыл ноль; настоящий выигрыш дала стоявшая поверхность, а в стволе найдена живая дыра состоятельности (f63cdc1)
• Семя перепечатано после слияний imena и uzel и сошлось на втором поколении (440800a)
• Одно действие, записанное вызовом и встроенной формой, доказывается одинаково (a2516ce)
• Драйвер PostgreSQL доехал до живой базы: октетная пара восстановлена у хозяина в C, поток драйвера стал октетным (f3ce2d9)
• Корпус HTTP перенесён на flang и снова кого-то проверяет: 55 входов, все сошлись, и шапка stdlib/http.flang опять не врёт (16bb043)
• Число строк библиотеки в спеке ядра догнало дерево: 12049 стало 12146 (1946857)
• Числа в комментарии и в заметке приведены к парному замеру: 3053 мс против 2404 (933041f)
• «Цифра числом» в библиотеке одна: постгрес берёт её ввозом из «Строк» (5076818)
• Семя перепечатано новым компилятором (82617dd)
• Значение привязки в постгресе называется «Значение с длиной впереди» (f01450d)
• Разбор «Результата» называется «Успех или запасное», а не как разбор «Возможно» (d1e5e58)
• Обрезка в HTTP названа по тому, что снимает: пробельные знаки, а не только пробел (549e214)
• Пять имён «Высшего порядка» называют то, чем функция сделана, а не только итог (450869b)
• Сортировка вставками доказана: свёртка читает шаг постусловием того, кого зовёт (24c5bd8)
• «Приписать в начало» в библиотеке одна: «Высший порядок» ввозит её из «Списков» (2b9fd24)
• «Чётное» в библиотеке одна: «Высший порядок» ввозит её из «Чисел» (ae46dd8)
• «Целая часть» в библиотеке одна, живёт в «Числах», и три модуля ввозят её (a3907b6)
• «Досыпать байты» в библиотеке одна: SHA-256 берёт её ввозом из «UTF-8» (ba10871)
• Правило соседних не отдаётся правилу ограниченности: цель «длина … не больше 1» принадлежит седьмому (578c54b)
• Рекурсия сортировки отделена от дорогого утверждения, и ещё два утверждения utf8 доказаны (d31409b)
• Ядро насыщает допущение о соседях: «Г : Х не убывает» распадается на порядок хвоста и границу головы (482a3b8)
• Удалён scripts/build-stdlib-index.mjs: печатник указателя на удалённом разборе, не грузится (8a85f50)
• Ещё одиннадцать утверждений библиотеки доказаны: вхождение по построению, «не больше» вместо «не меньше», разъятые конъюнкции (522b6ea)
• Квантор по соседним парам занял отвергаемую форму «не убывает», ядро получило седьмое правило (0fa312e)
• Удалён flang/examples/web/shortener/serve.mjs: ввозит удалённую реализацию; тот же сценарий уже есть планом на flang (18efb2f)
• Удалён flang/proof/search.mjs: ввозит удалённое ядро на JavaScript и не грузится (0be8536)
• Снят мёртвый узел связи на Node и починена ссылка на него (89bddf4)
• Снят мёртвый прогон примера-библиотеки (7d95994)
• Снято хранилище примера-библиотеки: единственный звавший ушёл (22cff28)
• Снят мёртвый HTTP-хозяин примера-библиотеки (501327b)
• Снят мёртвый мост примера-библиотеки к языку (8f22928)
• Снят мёртвый сетевой хозяин сокращателя (f5490b4)
• Снят мёртвый хозяин сокращателя с журналом (8a14567)
• Удалён flang/src/proofterm-probe.mjs: копия удалённого ядра на JavaScript, которая не грузится (5a4ff76)
• Снята мёртвая сверка распределённых узлов (1445 строк) (20b2294)
• Снят мёртвый замер планировщика (2068 строк) (d9cd3dd)
• Снят мёртвый разбор типов стенда (07f5e4d)
• Снят мёртвый замер стенки планировщика (52f04bd)
• Снята мёртвая печать стенда в Elixir (1bcfbb1)
• Снята мёртвая печать стенда в C (a7f3095)
• Функции как значения: сортировка по сравнению доказана, порядок вперёд и назад сведены тождеством (d3fe2b7)
• Сортировка устойчива и доказана: тело разбором вместо свёртки, «не теряет и не добавляет элементов» доказано индукцией по списку (3791c89)
• надзор поднимает упавший процесс на всех восьми целях (051d579)
• надзор поднимает упавший процесс и на цели rust (c5333f3)
• надзор поднимает упавший процесс и на цели java (7ea6603)
• надзор поднимает упавший процесс и на цели csharp (436d43c)
• HMAC-SHA1 сходится и с шестым вектором RFC 2202: ключ длиннее блока хешируется (18c83bf)
• надзор поднимает упавший процесс и на цели elixir (6b05374)
• надзор поднимает упавший процесс и на цели go (7e955f4)
• в шапке вывода ключа убран повтор абзаца о цене витка (0b58168)
• Точка раскрутки перепечатана этим деревом: она снова читает свой слой вычислителя (95f149b)
• надзор поднимает упавший процесс и на цели js (f99b7b3)
• у каждого утверждения о длине теперь есть пример: рантайм-сторожей в выводе ключа не осталось (fd9d170)
• надзор поднимает упавший процесс на живом узле: цель python, прогоном (c4ef71d)
• Двести ввозов дерева написаны именем модуля, через ../ осталось восемь (75e9c16)
• Круг «разобрал и собрал обратно» стал выразим: контракт больше не проверяется, пока считается контракт, и петля постусловия развязана преобразованием программы (2e2a698)
• в шапках драйвера и плана названа настоящая причина: пусковой пакет уходит нулём октетов (ba6da4d)
• База знаний пополнена тремя заметками, и число строк библиотеки пересчитано (62a66bf)
• SHA-1, HMAC-SHA1 и PBKDF2-HMAC-SHA1 сходятся с векторами FIPS 180-4, RFC 2202 и первыми двумя RFC 6070 (f8d89f0)
• двоичный хозяин пишет строку через strlen: пусковой пакет PostgreSQL уходит нулём октетов (4b8ec2a)
• клиент SCRAM-SHA-256 считает доказательство и проверяет подпись сервера (7bd68b7)
• полный узел работает на всех восьми целях: хозяин node.c, 1617 строк, мира 29 (afb42a9)
• Цена утверждений словаря измерена и урезана вдвое: 11,4 раза стало 6,3 (90d2654)
• В базе знаний записан измеренный факт: двоичный хозяин обрывает содержимое на первом нулевом октете, и драйвер PostgreSQL по проводу не идёт (d6bc2a0)
• Доказанное ядром постусловие в напечатанный код больше не едет: на stdlib снято 62 проверки при работе, цена утверждений на сортировке упала с 3,23× до 2,72× (b0f372a)
• полный узел работает на цели java: хозяин node.java, 1063 строки, мира 21 (aec9fcd)
• Сторож ссылок считает и ещё не добавленные файлы дерева (fd12e22)
• Страницы и указатель говорят: модуль подключается по имени, путь — только для чужой ветки и пакета (307068f)
• Десять чисел прозы, разошедшихся с деревом, приведены к замеру; на странице второго замера цены они стали подстановкой (3b325a9)
• Сверки с удалённой реализацией на JavaScript убраны: 44 файла, 31 394 строки (105943c)
• полный узел работает на цели rust: хозяин node.rs, 1158 строк, мира 17 (e5b6e15)
• Подделки ядра проверяются на flang: 3 файла, аксиом ноль, нарушений 0 (55214e3)
• Ведомость снова считается: утверждения переписаны так, чтобы ядру хватило сорока миллионов шагов (52e8c7a)
• У строки одна мера — знаки: содержит, начинается с и разделить больше не режут знак пополам, а соединить отказывает там, где два знака слились бы в один (5c4eb60)
• У строки одна мера — знаки: содержит, начинается с и разделить больше не режут знак пополам, а соединить отказывает там, где два знака слились бы в один (c015f45)
• драйвер PostgreSQL разбирает три сообщения SASL и собирает оба ответа клиента (81be03c)
• Сторож лицензионной разметки написан на flang: 81 публикуемый исходник, 0 отказов (69b26db)
• Узел по ссылкам прогнан на BEAM: работа доехала до имени с провода, а тот же узел без ссылки хоронит работника при «ok:true» и исходе «покой» (c41b08c)
• В package.json осталось три крючка npm, а сорок ярлыков зовутся через ./ярлык (88b565f)
• Сторож ссылок написан на flang и ловит ту же беду: битых ссылок 2 из 880 (ef6764d)
• На сайте есть страницы про базы данных, процессы и категорную поверхность, дорога «как учить язык дальше» и четыре схемы (f53279b)
• цель js вернулась в счёт вторым хозяином node.js: 575 строк, мира 15 (91065c9)
• Ввоз без пути разбирается, ищется по имени модуля и виден сторожу (fda57b0)
• HMAC-SHA256 сходится со всеми семью векторами RFC 4231, вывод ключа PBKDF2 — с вектором RFC 7914 (5f24e14)
• Узел раздаёт работу по именам с провода: адрес и тип принимаемого едут одним значением «Ссылка» от «Т», и груз чужого типа отвергается проверкой типов (3054a47)
• полный узел работает на цели elixir: хозяин node.ex, 877 строк, мира 12 (b0905aa)
• ключ приводится к блоку хеша: длиннее блока — хешируется, короче — дополняется нулями (d7906b3)
• Календарь разобран весь: двадцать три функции из двадцати четырёх несут утверждение, переживающее подмену тела (01c2d2f)
• свод выдаётся байтами, списки режутся началом и сливаются исключающим или (9de9dcc)
• список байтов печатается шестнадцатеричным, по два знака на байт (b462c11)
• слово из тридцати двух разрядов раскладывается на четыре байта и складывается обратно (d50e819)
• Ещё семь функций календаря, и ложное утверждение эталона снято (c7db98e)
• Пять функций календаря получили содержательные утверждения, и одно из них нашло ошибку в самом календаре (43960e7)
• UTF-8 закрыт: все 59 функций трёх модулей несут содержательные утверждения (e1ddd46)
• Разбор UTF-8 обвешан утверждениями: у четырёх функций хода их не было вовсе, «точек не больше, чем байтов» было даровым (fe189f2)
• Разговор с базой: четырнадцать утверждений о чтении ответа (147865b)
• Пять функций UTF-8: три даровых «не больше четырёх на символ» сняты, порядок досыпки и первый байт закреплены (5b34787)
• Двенадцать содержательных о словаре связями, и ловушка на повторяющихся ключах поймана до написания (e17b981)
• «Списки строк» закрыты, начат UTF-8: найдено первое НЕВЫРАЗИМОЕ — квантор по списку внутри постусловия (6ce107a)
• Двенадцать содержательных о множестве строк: вложенный отбор даёт квантор, которого у языка вроде бы нет (661e02c)
• Ещё пять «Списков строк»: три даровых сняты, у склейки и хвоста утверждений не было вовсе (9f457c7)
• Пять функций «Списков строк»: три даровых сняты, в том числе единственное в библиотеке, закрытое индукцией (95fe659)
• Восемь содержательных об опциональном значении, и второй ход ядра: «равен да» после вызова переводит цель из сетки в доказанное (235b4df)
• Утверждения удешевлены: то же самое сказано за постоянное время вместо обхода (4aadb0e)
• Разговор с базой: восемь утверждений о полях, беде и потоке (7c1424c)
• Восемь содержательных о результате, и найден ход: цель, зеркалящая дерево условий тела, переезжает из сетки в доказанное (49cd47f)
• «Строки» закрыты: 31 функция, 36 утверждений, даровым осталось одно — и оно оставлено нарочно (fb2d786)
• Восемь утверждений переписаны: у строки ДВЕ меры, и сшитое из форм разных мер утверждение ложно на одинокой половине суррогата (606b526)
• Семь содержательных утверждений о дереве чисел: сортировка начинается наименьшим, а вставка растит дерево ровно на одно число (598b419)
• Двадцать содержательных утверждений о числах, и все под сторожем: не число, бесконечность и минус ноль ломают половину очевидного (79f0b0a)
• Все двадцать четыре функции словаря хешем разобраны: у двадцати есть утверждение, переживающее подмену тела, у четырёх — записана причина, почему его нет (9a47d8e)
• Разговор с базой: семь утверждений о разборе вести (1bab435)
• Утверждения высшего порядка, функции 26–34: сжато ровно столько, сколько в коротком списке; наименьшее и наибольшее взяты из самого списка (59c5559)
• Утверждения высшего порядка, функции 21–25: на найденном месте стоит подходящее, состав есть два отображения подряд (61039c1)
• Утверждения высшего порядка, функции 16–20: счёт подходящих есть длина отобранного, все и любой сведены к счёту (1c7a491)
• Три вопроса о знаке и «Только цифры»: утверждений не было вовсе, написаны сверкой двух разных способов (6f34c22)
• Шестнадцать содержательных утверждений о словаре деревом: каждое переживает не заглушку, а враждебную сетку (79bf702)
• Утверждения высшего порядка, функции 11–15: порядок вперёд есть порядок назад с переставленными доводами, свёртка пустого есть основание (4b18462)
• Повтор и три обрезки: одно даровое стояло трижды, вместо него круговой ход плюс отсутствие пробела на краю (a67aaae)
• Регистр, разложение, переворот, палиндром: четыре даровых заменены, тавтология у палиндрома не написана (16502b6)
• Ещё пять строковых функций: даровое «позиция неотрицательна» снято, граница кругового хода регистра записана честно (3759c1b)
• Последние два ослабленных заменены полной спецификацией обрезки: ослабленных не осталось ни одного (a3fcf01)
• Разговор с базой: восемь утверждений о расширенном протоколе и о дополнении (5f7a422)
• Утверждения о первых пяти строковых функциях: даровое «счёт неотрицателен» снято, круговой ход и длины склейки записаны (bba04c1)
• Ещё пять утверждений: печать json и таблица знаков по коду; замер даёт 31 содержательное из 34 (550115e)
• Утверждения высшего порядка, функции 6–10: слагаемые и сомножители переставимы, меньшее с большим дают ту же сумму (23ddde5)
• Печать перестала выпускать непроверенное; предел шагов 200 млн по замеру; справка разрезана надвое под предел C99; связанная запись отдаётся выходным параметром (489863d)
• Утверждения высшего порядка, функции 1–5: противоположное складывается в ноль, чётное не меняется вычитанием остатка (d6dbc7a)
• Утверждения о списках, функции 26–28: удалено ровно столько, сколько было вхождений; пар ровно столько, сколько в коротком списке (09dabe4)
• Восемь функций словаря хешем получили утверждения, которые подмену тела заглушкой не переживают (ff4a4a0)
• Разговор с базой: семь утверждений о сборке сообщений клиента (da5cf1a)
• Шесть ослабленных утверждений http.flang заменены пятью содержательными: разбор цифр сказан обратностью таблице, цель — покрытием без остатка (7b36681)
• Утверждения о списках, функции 21–25: вставленное стоит в списке, первый элемент переживает отсев, счёт вхождений не ноль ровно тогда, когда значение в списке (b097783)
• Разговор с базой: семь утверждений о печати чисел октетами и о кадре (3151002)
• Утверждения о списках, функции 16–20: наименьшее и наибольшее взяты из самого списка, сумма неотрицательных не меньше наибольшего (d7a5419)
• Утверждения о списках, функции 11–15: найденное место держит искомое, поиск и обход согласны (4787e69)
• Ещё пять утверждений о http.flang: путь, схема и годность адреса сказаны через то, что они значат (739284d)
• Разговор с базой: шесть утверждений о резке потока по байтам (6d681f2)
• Утверждения о списках, функции 6–10: взятое считается точно, срез до конца отдаёт весь список, промежуток доходит до предела, обход сходится со встроенной формой (a530c52)
• Пять тавтологий json.flang переписаны содержательными, и размен назван: ядро их больше не доказывает (7a2b6ae)
• Пять утверждений о http.flang переписаны содержательными: замер подменой тела даёт 9 вместо 5, даровых не осталось (f8280b4)
• Утверждения о списках, первые пять функций: счёт звеньев сходится со встроенной длиной, отброшенное и взятое вместе дают весь список (b112be1)
• Разговор с базой: первые девять утверждений о знаках и байтах (65f64c3)
• Предел шагов поднят с 40 до 200 млн по замеру: связывание съедает 59 процентов само, ядро 141; обрыв перестал быть бесшумным — шаг, съевший больше половины, называет себя (47210dd)
• Таблица слов языка достаётся прогонщиком, а не командой: словарь и прогон поверхностей ожили — и нашли понятие, выпавшее из двух таблиц из трёх (41fe41c)
• Точка раскрутки перепечатана: предел 200 млн внутри, проверка перед печатью внутри, 24 155 542 байта (6b1017d)
• Проверка перед печатью восстановлена, и разведено чужое столкновение имён, без которого дерево не связывается (ad3d73a)
• Столкновения имён считаются обходом текста за 0,1 с — связывание отвечало за 6 минут (0559b9d)
• Круг обхода дерева разрезается записью-нагрузкой: семья печати литералов вынута и доказана (3991810)
• Двоичный печатает поток токенов: две проверки прозы ожили, и одна из них сразу нашла ложное утверждение суточной давности (f189a9c)
• Три столкновения имён разведены суффиксом слоя, точка раскрутки перепечатана: 24 217 343 байта (999662d)
• Литерал починен, цена названа числом, и указана настоящая причина дороговизны ядра (5a40cdb)
• Предел шагов поднят по замеру с 40 до 200 миллионов, и обрыв перестал быть бесшумным (06452ff)
• Сторож прироста от «веса» ожил: словарь типов спрашивается у двоичного (6d28909)
• Ведомость печатает обязательства целиком и спуски завершаемости (cafc41f)
• Подделки на оба правила прогоняются двоичным, а не мёртвым тестом (25e5fac)
• Точка раскрутки перепечатана: двоичный из семени печатает partialSites (4c071a5)
• Два правила ядра легли вместе: равенство в утверждении и цель-выбор с истинной ветвью (c98f2ca)
• Проза догнала дерево с одним компилятором: README на двух языках и man переписаны по прогону (fad6a48)
• Согласие спек проверяется планом на flang: 290 строк JavaScript ушли, в fspec/ их не осталось ни одной (d3d3933)
• Двоичный научился печатать места частичных форм: ключ partialSites в строке функции (8f6ebad)
• Полный узел заработал на четвёртой цели: хозяин на C# — 1101 строка, мира 14, решений ноль. Сверка восьми целей и печать переведены на двоичный (b8119a1)
• Отозвана собственная ошибка: значение-функция сравнивается верно, потому что дефункционализация делает её вариантом — лишняя проверка формы искомого снята, ложная подделка убрана, довод записан на её месте (d2bce78)
• Шестой ход ядра: цель-выбор с истинной ветвью — введение дизъюнкции слева, ведь «или» в языке разбирается в «если». Две подделки в дереве, изъятие проверки ветви «то» краснеет доказанной ложью (e5730e9)
• Структурное равенство узлов перенесено в ядро доказательства на JavaScript (deccd4b)
• Отказ «правила нет» и доводы про аксиомы выровнены между слоем и свидетелем: сверка ядра снова 29 из 30, единственный красный — сторож постоянного шага, он был красным и на github/main (28f8bc4)
• Второе поколение точки раскрутки: шесть файлов из семи совпали с первым, расходится только compiler_flang.c (59f3b70)
• Круг раскрутки замкнут прогоном без Node: 24 мин 50 с, семь файлов совпали байт в байт, и собранный двоичный тоже (f913ae0)
• Из справки убран абзац, ставший неправдой: «печать не проверяет типы и завершаемость» (6056021)
• Числа замера подставлены вместо выдуманных: 59 программ, и почти половина — ложные доказательства (00249ca)
• Числа точки раскрутки в bootstrap/README пересчитаны на нынешнем дереве (6b40f75)
• Разрешение конфликта в рантайме на C было неверным и не собиралось: их блоки звали машинерию, которую моя сторона удалила (8dd40e5)
• Печать модуля связи переехала на двоичный: 105 строк из 1117 разошлись, и обе стороны названы (2e6eda9)
• Шестое решающее правило доехало до слоя на flang: файл 03 закрыт вхождением по построению, стало 10 содержательных из 20; подделка про функцию-значение краснеет при снятии проверки формы (880d783)
• Уборка после удаления JavaScript в стволе: мёртвая печать снята, живое оставлено (5afc272)
• Незаконченная правка сторожей и запусков после удаления JavaScript: зафиксировано на обрыве лимита, продолжение по /srv/flang-rabota/sostoyanie-storozha.md (314e03e)
• Скрипт на JavaScript, печатавший точку раскрутки, удалён; релизный архив берёт её готовой из bootstrap/ (12d9867)
• Шестое решающее правило — вхождение по построению — заведено у свидетеля: подделка про чужой элемент и подделка про функцию-значение отвергнуты (перенос в слой на flang ещё не сделан) (b8a9d6d)
• Перепечатка точки раскрутки вернулась на путь сборки: печатает двоичный, сверка байт в байт цела (8c051ee)
• Полный узел заработал на третьей цели: go. Мира у хозяина 12 строк — меньше, чем у Python и у JavaScript (2f2570a)
• Допущение индукции приезжает ПО МЕСТУ ВЫЗОВА, переписка равенствами дошла до правила порядка, замкнутая арифметика считается, а склейка фактов по вызову больше не теряет их: стало 9 содержательных из 20 (72fe55e)
• Полный узел заработал на второй цели: узел на Python и узел на JavaScript ведут одну программу через настоящий провод (ec55079)
• Планировщик и таблица процессов узла переехали на flang: печатаются во все восемь целей, 67 744 сверки, расхождений 0 (41050dd)
• JavaScript удалён: 48 файлов, 56 072 строки. Компилятор один — написан на flang, собирается в двоичный, печатает сам себя и во все восемь целей (fe8e8a3)
• Точку раскрутки печатает сам двоичный: Node ушёл с пути сборки, обе печати совпали байт в байт (88b877d)
• Справка двоичного починена: перенос строки в тексте был буквальным, сборка -Werror снова чиста (4ed7c26)
• Восемь целей печати в двоичном: десять столкновений имён в замыкании разведены суффиксом слоя, точка раскрутки перепечатана — 23 903 453 байта (9bc9da6)
• Страница руководства называет, что печать проверяет и чего не проверяет (a8954a8)
• Столкновение имён снято переименованием: «Хвост строки» обходчика корпуса и языкового сервера — разные функции, совпало только слово; точка раскрутки перепечатана (c3bebbf)
• Печать двоичного спрашивает у проверки: разбор, типы, завершаемость и ядро — примеры названы пробелом (4428bcf)
• Четыре новых имени переименованы, а не помилованы; три отставшие ведомости пересняты пофайльно — и рост оказался стволовым (274d3c1)
• SPEC самоприменения знает про соседа по подкаталогу: прогонщик корпуса (18d328d)
• Компилятор на flang догнал правку: поле суммы из одного варианта и в типах, и в вычислителе (7792358)
• Проза, отрицавшая форму, догнала дерево: сторож утверждений чист (f54b527)
• Охват сторожа имён пересчитан: двенадцать подделок — образцы тестов, и решение записано (3a0cc72)
• Шапка прогонщика догнала дело: обходчик стал двумя строками (5f2e7a5)
• Точка раскрутки перепечатана после свода слоя ввода-вывода: 7 файлов, 15 513 900 байт, сверка совпала (d44898e)
• Числа прозы догнали дерево: 33 переписаны измерителем, три ложные тревоги сторожа пересказаны так, чтобы проза осталась верной, ловушка записана в базу знаний (f0e966f)
• Точка раскрутки перепечатана после свода границы входа: 7 файлов, 15 487 176 байт, сверка совпала (d20b8eb)
• Ведомость тоже смотрит разобранный вход: программа с четырьмя свойствами печаталась зелёной (cb0e9ad)
• Отказ без довода называет и каталог: команда принимает не только файл (81276bd)
• Подсказка «как запустить напечатанное» проверена прогоном и поправлена у трёх целей из восьми (9fff8d6)
• Обходчик примеров дерева переведён на flang test: 35 строк оснастки заменены одним вызовом (9d3c202)
• Числа сайта и описания пересняты на собранном дереве: тотальных 7899 из 9854, доказано ядром 239 из 409, аксиом ноль (9cc1cff)
• Цена нового отклика предъявлена и уплачена: разбор «Отклика» без запасной ветки обязан дописать ветку (e468ed3)
• Числа прозы пересчитаны прогоном после правки проверок восьми целей (c874e3f)
• Отчёт различает три числа примеров: свои прогнанные, чужие прогнанные и потерянные с отказом (8b68b57)
• Поле суммы из одного варианта доехало до печати: восемь рантаймов и точка раскрутки (1fe3126)
• Числа прозы догнали дерево, и заметка про срок назвала своё настоящее место — машину состояний связи (93b0a58)
• Проза догнала свод: справка, страница руководства и сайт больше не обещают одну цель из восьми (a9cf1aa)
• Прогонщик считает СВОИ примеры отдельно от ввезённых: девять файлов на 11 683 строки отчитывались чужими (6eea2b4)
• Проза догнала бинарник: справка, страница руководства и страница установки называют весь пробел, а не половину (9f464f8)
• Проверки формы написаны НА FLANG: двоичный считает 68 из 68, и отрицательные — обычным «пример» (8c6d8f0)
• Контракт назвал числа после слияния: 17 472 сверки решения о связи и 3672 сверки провода на восьми целях (e4d0343)
• Надзоры из плана сверены дважды: со свидетелем и с разбором; конец связи на Python догнал пятый признак (aaa8f98)
• Сторожа имён и счёта возвращены в исходное: ноль новых нарушений от этой работы (d978de0)
• Свод догнал числа: описание самоприменения перестало отставать от дерева, новая страница замера встала под запрет жаргона (f666033)
• Подделка на каждое объявление и проверка на сам сторож: изъятие обязано краснеть (a4b0b0d)
• Бинарник перестал принимать неверное молча: суд по составу правил, а не по трём из четырнадцати (345972e)
• Возврат web/app и web/wasm, снесённых по моей ошибке, и снятие закрытой строки долга (9ce17f3)
• Точка раскрутки перепечатана, и собранный двоичный принимает форму сам (27a78ae)
• Хозяин в C догнал словарь: октеты, ввод потомка, срок ключом — и вывод обоих совпал байт в байт (9682dec)
• «надзорыИзПлана» открыта наружу: сосед просил, и это дешевле, чем оставить 12 строк непроверяемыми (b0fb737)
• Браузер заговорил со службой: три кириллических маршрута из трёх, было ноль из трёх (6ed8154)
• Обёртка «потерять» убрана: решать, докладывать ли о разрыве, узлу больше нечем (4b59aea)
• Три дыры выразимости закрыты формами, которые разбор прежде отвергал (fa953d6)
• Сторож чисел поправлен: число про distributed.mjs называет день и способ замера (b575b1d)
• Ввод потомка и срок хозяина проверены планом на flang, а не мимо языка (1d62340)
• Сверка «Долгов» с деревом стала зелёной: 22 раздела из 22 (f2150c4)
• Сторож печати плана переехал из рабочего пути: потолок 29 722 строки JavaScript восстановлен (b5979b7)
• Вторая цель заговорила: конец связи на Python пожал руку узлу на JavaScript по настоящему сокету (8b50503)
• Улика и починка октетов под проверкой: 557 октетов настоящего PostgreSQL проезжают байт в байт (b48a5a9)
• Цена обнаружения дыры в потоке посчитана в контракте: поле в кадре и два числа на связь (328b50a)
• Словарь ввода-вывода вырос на три поручения и один отклик: октеты списком чисел, ввод потомка, срок хозяина ключом (d0678d9)
• Напечатанный модуль связи получил лицензионную разметку: печать её не ставит и ставить не должна (4b3ffcc)
• Развилка «два надзора над одним процессом» названа: из трёх исходов два уже видны, третий стоит пятого кадра (b1e58b7)
• Контракт распределённости догнал прогоны: девятнадцать испытаний, шесть строк ведомости из «объявлено» в «сделано» (d5dd52b)
• Принятый сокет, который не назвался, закрывается за 704 мс при сроке 700 вместо вечного ожидания (6b4e850)
• Контракт и база знаний догнали замер: строка «мир 459, на flang нет» поправлена разбором, а не стиранием (aa930df)
• Четыре ветки без прогонов получили прогоны: обратное давление, «через N», запас витков, «остановить» над представителем (f1aa403)
• Часы хозяина на C пошли в миллисекундах: было пять одинаковых замеров подряд, стало три разных (45534aa)
• Проза догнала дерево: спецификация описала печать плана, база знаний поправлена, сторож чисел стал чист (2ff91f9)
• Проза слоёв самоприменения и точка раскрутки догнали пометки (773591c)
• Узел перестал решать сам: жизнь связи ему печатает компилятор, и 13 прогонов по настоящим сокетам зелены (76358b0)
• Восемь близнецов печати на flang догнали форму: 8 из 8 сверок зелены (c72e881)
• Проза двух примеров догнала анализ: убывание числа он принимает, и цена этого названа (835369e)
• Прогонщик корпуса: течи на путях отказа закрыты, а руководство узнало про каталог и маску (cd5e451)
• Эталон надзоров из плана: перевод сверен с разбором на 9 программах, 11 надзоров, изъятие краснеет на всех (113bd5b)
• Близнец на flang догнал форму: лексер, разборщик, типы, вычислитель, формы, отказы (5c8bc18)
• flang в Vim и Neovim: правила подсветки напечатаны из таблицы языка, а сервер найден четырьмя путями и проверен настоящим редактором (3fd8b4e)
• Срок первого знакомства: сосед, который не поднимется, назван за 803 мс вместо вечного молчания (0ab9213)
• Сокеты и часы стали решением на flang: жизнь связи — чистая машина состояний, 307 строк эталона (0a0dfeb)
• Путь установки проверяется целиком: четыре способа, семь команд на каждом, и шестая поломка ловится прогоном, а не человеком (71c5dee)
• «Пробелы» объявлены натуральным числом, и сторож ушёл: доказательство стало статическим (a06d3be)
• Имена в прогонщике корпуса развёрнуты, а числа прозы догнали дерево (f931f0a)
• Двести девяносто три функции корпуса были тотальными и без пометки: анализ берёт их как есть (f2d60bb)
• Заготовка заявки в linguist перестала ссылаться на четыре каталога, которых нет (35a4343)
• Контракт разбора моделей назван тем, что он делает, и его критерий готовности приведён к дереву (80ad639)
• Руководство, описание языка и спецификация приведены к дереву: старого проекта в них больше нет (2fd8298)
• Сторож жаргона: внутреннее слово больше не имеет права попасть в текст для читателя со стороны (642bab6)
• Найдена ошибка библиотеки: Content-Length считается знаками, а не октетами — и чинится не одной строкой (97e109f)
• Правка рантайма 0.5.1 догнала точку раскрутки: две строки исходника, шесть килобайт печати (3bfe929)
• Слой доказательств получил первые собственные примеры: пять на обязательства и ядро (1c1df90)
• Точка раскрутки догнала исходники: слияние с конфликтом оставило её на день позади (da2b7f3)
• Форма напечатана во все восемь целей: рантаймы сошлись знак в знак на 15 входах (8550b98)
• Хозяин вкладки перестал ввозить компилятор, и приложение поехало из напечатанного модуля: 1 768 447 байт стали 102 675 (d68bd04)
• Страница руководства называет две цели печати вместо одной: c и elixir, а недостающих шесть (9c78283)
• Сокращатель перестал держать свою копию: 67 строк сняты, числа деревьев пересчитаны прогонами (c679a9e)
• Суррогат решено отвергать: 1 112 064 скалярных значения замыкают круг, все до одного (dbbf2c8)
• Печать плана написана на flang и сверена побайтово: 108 программ корпуса из 108, включая программу с планом (6464f66)
• Предел раскодирования в http закрыт: круг замыкается на 1 114 112 точках из 1 114 112, было 95 (cf2e8de)
• Справка emit перестала врать про обе цели: C# отбрасывает недостижимое, а границы входа у чужой программы нет ни у одной (b18a089)
• Числа сверки восьми целей в контракте пересчитаны прогоном: 456 вопросов, 3648 сверок (17bf1df)
• Справка двоичного больше не врёт про Java: целей названо две, и про каждую сказано, чего у неё нет (d94c2d7)
• Однобуквенное имя в эталоне переименовано: сторож имён поймал «м» (789a6f7)
• Печать перестала молчать о плане, а JavaScript научился его печатать: восемь целей отвечают, семь отказом (e0afec6)
• Двоичный печатает в Java: 7 столкновений имён разведено, долг границы входа закрыт, и напечатанное запускается (0d17aa7)
• Граница входа теперь строится на flang: программа, напечатанная двоичным, больше не берёт -3 на типе «нат» (cf67fa3)
• Форма «символ по коду» заведена в рабочем пути: 21-я встроенная, обратная к «код символа» (feb12e8)
• Границы кадров переехали в эталон и сверены рваным потоком: 797 знаков, резаных по 7, дают ровно 10 писем (c4c2f37)
• flang test берёт каталог и маску: прогонщик корпуса написан на flang (bfa9872)
• Перепись переcчитана прогоном: 1 764 байта на процесс не воспроизвелись, вышло 1 948 (a00ecb0)
• Из npm теперь ставится тот же двоичный компилятор, что из brew: расхождений было 54 из 59, стало 7 — и все семь названы (ed4090a)
• Суффикс цели переведён на CSharp, как у карты разведки и соседних веток: 316 имён из 324 совпали с картой поимённо (891455e)
• Двоичный печатает в Python: долг границы входа закрыт 161 строкой на flang, ключ --target заведён 127 строками C, вне границы расхождений 0 из 102 (68d7a82)
• Четыре беды одной команды: каталог заводится, жаргон убран, рантайм едет в архиве, тест называет обе стороны (8beae33)
• Граница входа у печати в JavaScript печатается, а не вычитается: сверка со свидетелем стала 107 из 107 на всех байтах (9ef941f)
• Вход по паролю открытым текстом проверен настоящей базой: поддержаны два способа из шести (104ac38)
• Ведомость отвечает первой строкой: 26 строк на одну функцию стали 14, словарь ушёл за ключ (ea5619b)
• Отказы компилятора проверяются на flang: 9 примеров вместо проверок на JavaScript (d9d68c7)
• Целое длиннее пятнадцати цифр объявлено неразобранным, и минус ноль проверен примерами (52afcce)
• Контракт распределённости догнал прогоны: вторая цель посчитана числом, кворум назван развилкой (5a0ea6a)
• Убран тип, который никто не может построить, и названо следствие: типов колонок у программы нет (adb48d0)
• Двоичный печатает в C# из командной строки, и долг границы входа закрыт: напечатанное собирается dotnet и отвечает {"ok":true} (a3a5001)
• База знаний: четыре заметки о том, что выяснилось на драйвере, и охват сторожа имён пересчитан (aeb3f07)
• Двоичный печатает в Elixir: ключ --target elixir работает, а долг границы входа закрыт — 108 программ из 108 побайтово без единого вычитания (07040fb)
• Двоичный печатает в JavaScript: 102 программы корпуса из 102 совпали с Node побайтово, кроме одного названного блока (cae4c01)
• Закрыты три дыры, найденные замером по настоящим службам дерева (a85747e)
• Печать в JavaScript въехала в замыкание двоичного: неподвижная точка сошлась 37 из 37, C вырос на 1 056 833 байта (d18e567)
• Драйвер PostgreSQL на flang: настоящая база отвечает, и граница языка названа числом (c7690d4)
• Воспроизводимость по семени предъявлена прогоном: 6 семян, 12 прогонов, 6 разных журналов и ни одного расхождения внутри семени (bb6f826)
• Предел пробега стал ДОКАЗАННЫМ сроком: 47 витков вместо миллиона у 55 мест из 60 (aef7ed3)
• Двоичный печатает в Go: 163 программы корпуса, 159 расходятся со свидетелем только границей входа, 1 — транслитерацией, и оба расхождения есть у цели «c» (2beb35e)
• Проза о границе выправлена: эталон stampFile написан, и правило «файл один — беда его» названо на обеих сторонах (14bb1f7)
• Двоичный печатает в Python: 302 столкновения имён разведены суффиксом, 391 объявление цели переименовано (a8f1938)
• Обратная сторона провода приехала в эталон: раскодирование на flang, 402 значения корпуса сходятся оборотом (d45c8b8)
• Двоичный отвечает редактору: flang lsp — 47 столкновений имён разведено, сессия LSP сверена с Node побайтово (6516ea7)
• Печать в C# втащена в замыкание двоичного: 4261 функция против 3919, ноль столкновений, сборка без единого предупреждения (70bf3c2)
• Печать в Rust втащена в замыкание двоичного: 2 столкновения имён на 234 объявления, и долг границы входа закрыт — 108 из 108 программ побайтово (892780f)
• Печать в Elixir втащена в замыкание двоичного: 262 столкновения имён разведены суффиксом, замыкание выросло до 400 типов и 4294 функций (a18bb10)
• Печать в Java втащена в замыкание двоичного: 7 столкновений имён разведено, связанных функций 3919 → 4247 (a153b73)
• Имена печати в JavaScript разведены суффиксом: 141 столкновение стало 0, корпус сошёлся 107 из 107 (6d86ab1)
• Печать в Go встала в замыкание двоичного: столкновение одно из 197 привезённых имён, и границу входа эталон печатает сам (38b9fb2)
• Печать в C# развела все свои имена: 395 объявлений получили суффикс «шарп», сверка со свидетелем осталась 107 из 107 (b2998c6)
• ADR-0003: решение «свою BEAM писать не надо» отменено, своя машина пишется (44070ac)
• Ключ --args и стрелка описаны там, где их ищут: 5 прогонов в страницы, 3 написания стрелки названы (926abf4)
• Ведомость пакета берётся у прошедшей проверки: второе ядро в дереве убрано (a444d75)
• Сторож имён считал копии деревьев исполнителей: 809 файлов превратились в 9708 (471bbee)
• Свидетель словаря свойств стёрт: 163 строки JavaScript, ни одной проверки не потеряно (c937d8b)
• Свидетель сетки нарушений стёрт: 202 строки JavaScript, ни одной проверки не потеряно (1be151e)
• Бюджет ядра свой: 40 млн витков роняли команду там, где свидетель отвечал за 87 мс (a2b0986)
• Свидетель равенства морфизмов стёрт: 786 строк JavaScript, одиннадцать проверок названы (6cda817)
• Свидетель законов множеств стёрт: 292 строки JavaScript, одна проверка снята (5a40bea)
• Свидетель квадрата связи стёрт: 363 строки JavaScript, десять проверок названы (2e8bc56)
• Ядро доказательств переключено на слой flang: три файла и 6 442 строки ушли из рабочего пути (1a8fb1d)
• Транслит ушёл из релизного архива: компилятор печатается в compiler_flang.c, и починено это в имени модуля, а не в генераторе (ec3806e)
• Служба на flang ходит наружу: «Открыть соединение» открывает сырой сокет, а вся сетевая четвёрка названа одним словом (66b9406)
• Восьмой ход доехал до эталона на flang: постусловие вызванного стало фактом, а круг закрыт неподвижной точкой (c5dfbc9)
• Четыре свидетеля ушли с рабочего пути: 27 файлов и 37 081 строка стали 23 и 35 991 (0ac93b3)
• Девять программ сошлись побайтово: сторона на flang читает порядок соседей и свёртку, растущую ровно на один (435756a)
• Исход счёта стал суммой из четырёх: отказ называет ЛОЖЬ, и расхождений 14 из 324 (0f3d722)

Ещё 594 правки языка снаружи не меняют.

0.5.1 — 19 августа 2026

• Выпуск 0.5.1: сборка на Mac починена, и скрипт выпуска перестал искать несуществующий файл (6d845f9)
• Библиотечная дверь напечатанной программы проверяет типы: чужой код получал мусор молча (c5b64d4)
• Пакет назван именем языка, и три страницы перестали учить команде, которой нет (80d1288)
• Сборка на macOS чинится вторым макросом: brew install не доходил до конца ни у кого на Mac (d187ac0)
• Четыре сторожа прозы снова зелёные: 53 числа пересчитаны деревом, а не памятью (1dcf19a)
• Признак у оракула функтора читался печатью и был ложен всегда; четыре заметки базы знаний (18f9de9)
• SHA-256 на flang: 37 функций, все тотальные, сверено на пяти официальных векторах (a09bae1)
• Сетка отношений множеств переключена на слой: checkSetLaws больше ничего не решает (87aa8cd)
• Байты UTF-8: перевод текста в байты и байтов в кодовые точки, 16 функций (7277eb9)
• Двоичный собирает пакет: flang package — десятая из десяти команд (c5c53a3)
• Исход прогона стал замкнутой суммой и у эталона на flang (b18aa61)
• Равенство морфизмов переключено на слой: setoid.mjs ушёл из рабочего пути (b343fb6)
• Двоичный читает замок: программа собирается из груза, прежняя схема отвергается (ee8f60a)
• Граница вычислителя: исход прогона стал замкнутой суммой у свидетеля (8c56ffe)
• Двоичный собирает замок: flang lock без Node, 20 сверок байт в байт (2b8deaf)
• Ответ ядра наружу оставлен побайтово прежним: список неоплаченных — связь внутри ядра (892c1b0)
• Ядро: восьмой ход — постусловие вызванного как факт на месте вызова (fb0187f)
• Точка раскрутки перепечатана поверх слитого ствола: 3868 функций (3fdb904)
• io: место отказа, имя плана в пределе и код 3 у ненайденного плана (3289026)
• Двоичный умеет io: хозяин с эффектами написан на C, план прогоняется без Node (5318745)
• Точка раскрутки перепечатана: восемь новых функций эталона в bootstrap/ (2002462)
• Правило «не минус ноль» перенесено на сторону flang: поле, два источника и четвёртый проход сужения (e050585)
• Точки входа плана на flang: найти, начать, шагнуть (063ac89)
• Точка раскрутки перепечатана поверх слитого ствола: 3847 функций (a9a6f31)
• Три коротких имени в точке входа развёрнуты: сторож имён вернулся к прежнему долгу (b78af89)
• Правило «свёртка растёт ровно на один» и сличение с точностью до порядка соседей (24291c7)
• Поле «не минус ноль» на числовом типе и дно из неравенства нулю (cf33543)
• Двоичный умеет facts: вердикт байт в байт как у свидетеля (69c88a3)
• Замок схемы 2: brotli из формата убран, адрес модуля — sha256 исходника (5b6e0c7)
• Факт-чекинг втащен в замыкание компилятора: 21 столкновение имён разведено (5e597ac)
• Указатель библиотеки пересобран после слияния ствола (6dcfa7d)
• Слияние ствола, перепечатка точки раскрутки и измеренный ноль на именной границе (06e9a93)
• Числа прозы и замеров перемерены под семнадцатый модуль (ce8f540)
• Корпус: ещё четыре цепочки номеров переписаны на «нат» целиком (ba9abe9)
• Корпус: шесть параметров-номеров объявлены «нат» вместо «число» (84e19e3)
• Точка раскрутки перепечатана: правило случаев доехало до C (caa29d7)
• Класс номера: правило целости встало в ПАРУ, плюс два правила границ — 89 из 271 стало 92 (e0330da)
• Квадрат связи переключён на слой: рабочий путь 29 файлов -> 28 (c60a5ec)
• Двоичный умеет ast: дерево разбора байт в байт как у свидетеля (734bfa3)
• Оракул функтора написан на flang и проходит проверку: 320 строк, 0 диагностик (03163f8)
• Шапка failures.flang говорит, откуда файл: две редакции, что взято и почему не склейкой (5989955)
• Сторона на flang: тот же принцип, позванный с пути постусловия (df540a7)
• Двенадцать однобуквенных имён взятой редакции переименованы: сторож имён вернулся к прежнему числу (a44cf80)
• Запросы и ответы: 17 постусловий там, где их не было ни одного (021842d)
• Страница сокращателя: замер шести нужд службы и раздел про журнал (a9d5f31)
• Класс номера: целость номера читается со сторожа «остаток от 1 равен 0» — 86 из 271 стало 89 (c3ef865)
• Улика на основание 64: 520 случаев сверки с Buffer, расхождений ноль (0ffdd35)
• Индукция по разбору на пути объявления: ядро само ведёт базу и шаг (ccc4ebb)
• Хозяин: allowHalfOpen — служба получила право подумать между запросом и ответом (18a49ba)
• Основание 64 закрыта: кодирование и раскодирование по RFC 4648 (60f1ae7)
• Служба связана с журналом упреждающей записи: подтверждение только после записи (c909f7f)
• Две редакции failures.flang сведены: взята полная, таблица кодов приехала из второй (b59b281)
• Основание 64: азбука, шестёрки и тройка байтов (3aeee7f)
• Свидетель законов выброшен: семь модулей на JavaScript и 207 проверок (3a6c59f)
• Примеры доехали до двоичного и до прозы; долг печати бинарника назван числом (ab0f88e)
• Предел сетки моноида и изоморфизма: копия в пути вместо ленивого чтения у слоя (5385822)
• Моноид и изоморфизм переключены на flang: рабочий путь 36 файлов и 37 371 строка → 29 и 36 349 (a0e7802)
• Оракул моноида и изоморфизма переехал в дерево: 713 и 6 строк таблиц сошлись знак в знак (454d610)
• Числа прозы о свидетеле поправлены на измеренные: 2140 строк, а не 2141 (0b88c4c)
• Утверждений о планировщике стало 15, доказаны ядром все 15; четыре ожидаемых проверены на выразимость поимённо (72ac2a4)
• Сверка планировщика выросла с 264 исполнений до 336, изъятий с 11 до 19, словарь сверяется на 174 программах (78875d4)
• Планировщик процессов на flang: 260 строк стали 2048, сверка на 264 исполнениях сходится (964d0a5)
• Числа прозы догнали дерево после слияния ствола 0a87f260: 13 расхождений (d63ec85)
• Ствол влит; три коротких имени выправлены; четыре заметки в базе знаний (9319177)
• Имена файлов и сторожевые списки приведены к новому словарю (3925559)
• Код переведён на новый словарь, точка раскрутки перепечатана (7278119)
• Спецификация самоприменения: состояние шести генераторов кода догнало дерево (da35879)
• Проза переведена на новый словарь: эталон — слой на flang, свидетель — JavaScript (7862010)
• Дыра уравнения ветви закрыта проверкой: образец, перевязавший разбираемое имя (5e64b9d)
• SPEC ядра доказательств: раздел о мере списка с числами и списком подделок (8a95ed3)
• Версия набора правил 11: отказ правила порядка называет все случаи меры целиком (6e47681)
• Точка раскрутки перепечатана после правки лексера: 13 304 108 байт (82424e9)
• Порядок таблицы лексера сведён с образцом; раскладка связывания и долг имён переснята (8033924)
• Эталон догнал свидетеля на доказанной непустоте: семь целей печати из восьми (e0ce3f4)
• Числа README и flang/self/SPEC.md догнали дерево: сторож раскладки чист (a12a847)
• Порядок ключей results восстановлен: свойства зовутся на прежнем месте таблицы, а не после неё (12f6497)
• Тождество читает длину как меру: отказов stdlib 80 -> 77, корпус 111 открытых (c66267b)
• Сторож чисел прозы чист: последние пять расхождений выправлены (d4cc71a)
• Постусловие границы снято: сторож всего дерева зелен на этом файле (94fea93)
• Обрубок в имени оракула развёрнут: «знач» стал «вычисленное» (370123e)
• Сторож на собранный HTML, оглавление через разбор, замер сборки двоичного перемерен (0042336)
• Девять чисел прозы догнали дерево; в стороже осталось 47 (34be51e)
• Постусловие зовёт только местные имена: сторож всего дерева зелен (c80884c)
• Пять свойств переключены на flang: рабочий путь 36 файлов и 37 270 строк → 31 и 36 530 (98b5310)
• check гоняет примеры: ложный пример больше не печатается в цель (11d2f02)
• Форма диагностики, границы чисел и кодовые точки: 270 новых точек сверки, 0 расхождений (0eb103b)
• Сторона на flang: мера списка перенесена целиком, близнец сошёлся с эталоном (59b927d)
• Учебник, страница руководства и обходчики зовут команду, а не путь в сборку (271de16)
• Одно имя у программы — «flang»: так называет её и сборка из исходников (b517cc8)
• Имя вида и описание значения сверены прямо, границы представления названы (e8601c9)
• Голая «flang» открывает оболочку; «--help», «-h», «--version» работают (0fd73cf)
• Лицензионный гейт снова зелёный: шесть файлов замера конкурентности несут SPDX (ac6acba)
• Числа прозы переписаны измерителем, а не руками: сторож чисел научился чинить (a1d4489)
• Равенство значений и порядок процента: 303 пары и 484 пары, 0 расхождений (e7481d2)
• Пара догнана после слияния: справка io у близнеца и потолок ствола (c742d5a)
• Оракул свойств переехал в дерево: 441 строка на flang, 706 строк таблиц сошлись знак в знак (605cd5c)
• Пакеты: библиотека в одном файле, подключение одной строкой, сборка без сети (d1dbff6)
• Побайтовая сверка встроенных форм: 8001 имя, 556 отказов, 320 помощников, 214 программ — 0 расхождений (62048d2)
• Сторона на flang для горячей замены: первая редакция (0d1de88)
• Правило порядка научено мере списка: 91 отказ stdlib стало 80 (465d947)
• Словарь встроенных форм собран в один файл на flang: имена, синонимы, арности, частичность (55bac10)
• Витрина Rosetta научилась показывать доказанное: 5 задач из 14 вместо 2 (20bf2ec)
• Словарь перевёрнут в шести сторонах и сверке: flang — эталон, JavaScript — свидетель (3801845)
• Версионирование документации: числа подставляются из замера, страница выпусков печатается из тегов (f24199c)
• Монотонность считает flang: пятое свойство сверено, все 24 записи корпуса совпали (3fee55d)
• Частичный порядок считает flang: три закона и карта здоровых сверены побайтово (4f187b2)
• Дистрибутивность считает flang: обе стороны закона сверены побайтово, расхождений 0 (d13349a)
• Идемпотентность считает flang: обе формы закона сверены побайтово, расхождений 0 (958c8eb)
• Коммутативность считает flang: 226 программ корпуса сверены побайтово, расхождений 0 (b0c1153)
• compat.mjs разделён: перевод модели FTS вышел из рабочего пути, 230 строк вон (0f04207)
• Роадмап и разборы перемерены деревом; спецификация уехала в конец раздела «Язык» (70aa6f2)
• Витрина Rosetta научилась показывать доказанное: 5 задач из 14 вместо 2 (565d863)
• obligations.mjs вышел из рабочего пути разделением: 252 строки JavaScript вон (51a789a)
• README журнала: числа, границы и честный список того, чего он НЕ гарантирует (6a8c926)
• Постусловия у словаря хешем: ещё 9 утверждений о границах хеша (a72d544)
• План дописывания и прогон корпуса: 75 проверок, все зелёные (00a35e0)
• Журнал упреждающей записи написан на flang: 25 функций, все тотальные, сторожей ноль (a2e15c9)
• Близнец: убрана мёртвая «Без последней части», тавтология заменена утверждением (ebf4318)
• Границы подстрока доказываются четырьмя фактами, и именная граница пережила вычитание: 19 мест из 212 стало 52 (45d7856)
• DISTRIBUTED.md: ведомость близнеца и честный список невыразимого (3790a83)
• Постусловия у высшего порядка: ещё 12 утверждений о длине результата (c5f3450)
• Постусловия у словаря, дерева чисел и дерева-словаря: ещё 12 утверждений (83791df)
• Постусловия у логики, опций, результата и списков строк: ещё 21 утверждение (3a33ad8)
• Близнец распределённости: flang/self/distributed.flang (55587dd)
• Постусловия у списков, строк и множеств: 39 утверждений о длине и знаке (d18c1e9)
• Седьмое поручение и код выхода: «Запустить процесс» отвечает двумя откликами, а flang io различает «нашёл беду» (1) и «сам сломался» (3) (db9a25f)
• Два места, где дерево врало само себе, перемерены прогоном: 57 773 в 57 и зазор ядра 0 из 301 (633e411)
• Права на два файла возвращены: их сменил npm, а не правка (ff65da0)
• Четыре страницы: установка, операции, пакеты, разборы — всё прогнано (dbf2df9)
• Словарь ввода-вывода вырос на «Перечислить каталог»: 1122 проверки дерева перестали упираться в «прочитать можно только названный файл» (120e688)
• Порождённый C перепечатан после языкового сервера (063d2f4)
• Числа прозы перемерены деревом после всех семи слияний, и дубли в своде сняты (db97373)
• Порождённый C перепечатан после обхода занятых имён, три числа прозы перемерены (73bee76)
• Порождённый C и рантайм перепечатаны после арены памяти (d7c344c)
• Порождённый C перепечатан после встречи со стволом (763c8b8)
• Порождённый C перепечатан после зазора ядра (a5be510)
• Точка раскрутки перепечатана после встречи со стволом (7f64a15)
• Ссылка на эталон наборов поправлена: файл переехал, а восемь близнецов не знали (4d372c5)
• Довод «почему счёт не аксиома» написан, а не обойдён: сторож аксиом поймал слово без довода (fd48792)
• Правило записано в SPEC: имя модуля и имена, занятые целью (cd3844e)
• Точка раскрутки перепечатана на новом стволе: 7 файлов, 12 883 135 байт (9b8a92b)
• Проза догнала закрытый зазор: план выброса эталона и спека ядра говорят 291 из 291 (8e9f1a4)
• Два файла вернулись в ведомость: только не покрывал того, что ввёз вычислитель (34bf938)
• Четвёртый ход проведён руками: три программы зазора сошлись с эталоном (115ba46)
• Вычислитель ввезён в ядро-близнец: четвёртый ход получил чем считать (aef255a)
• Пятнадцать функций «Свободные имена» переехали слоем ниже: решать про замкнутость обязан тот файл, где стоит ход (8025fba)
• Обход стал суффиксом у всех восьми: приставка flang_ у бэкенда уже занята (0593d2c)
• Числа прозы сведены прогоном: обход занятых имён прибавил строк и функций (705a83b)
• Точка раскрутки перепечатана: обход занятых имён въехал в замыкание (edffa79)
• Таблицы занятого переехали из src/emit: тот каталог — реестр целей, а не полка (8c0d260)
• Печать обходит имена, занятые целью: восемь бэкендов и восемь близнецов (ff1d751)
• Дефект назван и померен: имена, занятые стандартной библиотекой цели (99fff55)
• Сторожа сведены после границ номера: ведомость, потолок, слой types (b27d04a)
• вес въехал в близнеца: 24 отказа по имени сняты, остались два по ядру (742d251)
• Точный десятичный въехал в двоичный: 27 примеров денег бинарник берёт сам (bf2fdf7)
• Масштаб доехал до близнеца: точный десятичный стал типом, а не именем (88b043c)
• Справка близнеца на flang догнала эталон: раздел про замок есть в обоих (50a776e)
• Потолок рабочего пути поднят на 88 строк и разобран пофайлово; замок в путь не входит (a800cfc)
• Предел на проверку: зависший файл называет себя, а не молчит до чужого срока (e08797d)
• Близнец догнал: длина помнит контейнер и на flang, точка раскрутки перепечатана, неподвижная точка сошлась (4cc5703)
• Печать груза считается по тексту, а не по канону: переставленный ключ отвергнут (1f2274d)
• Сторож временных каталогов: прогон, оставивший мусор, называет его числом (5229097)
• Отказ flang lock без файла встал до ввоза модуля, а не после (aa7bdba)
• Сторож предобработки заведён в npm-скрипты: comparison:check рядом с emit:check (e992c28)
• Замок без склада записан числами: 7,6 КБ, цена имён 25 %, обновление целиком (48b6cac)
• Порядок ключей в замке сохранён: печать из замка совпала с печатью из исходников (1be224c)
• длина X помнит X: три тавтологии из корпуса убраны, доказанных мест 18 → 19 (effdfae)
• Порт отдаётся системе всегда: закрытие слушающего сокета вписано в flang io, и в finally, а не после (99de1d6)
• Точка раскрутки перепечатана после правки близнеца: неподвижная точка сошлась (6171774)
• Замок несёт сами зависимости: программа собирается из него без исходников (9643adf)
• Ведомость точки раскрутки: байты сошлись точно, время сборки перемерено (77 -> ~90 с) (720d35e)
• Свод подстроки измерен и записан: 6 мест из 82, и препятствие названо числом (d0cc771)
• Точка раскрутки перепечатана в том же коммите, что и правка близнеца (0f9bc2e)
• Числа прозы сведены с деревом сторожем, а не памятью: восемнадцать расхождений закрыты, счётчик чист (76b8736)
• Контракт назвал экран: «пять действий» стало «семь», и появилось второе слово (6f900cb)
• Числа прозы догнали дерево: три из них сдвинула эта правка, восемнадцать пришли с слиянием (312b6da)
• Числа в прозе догнали дерево: сторож был красный в 7 местах, стал чистым (512551d)
• Красные сверены ИМЕНАМИ: заявленная чистая база занижена, и ни один красный не мой (f18656f)
• Цена нового варианта отклика предъявлена компилятором, а не молчанием: разбор, перечислявший «Отклик» целиком, отказался собираться (1966aef)
• Близнец отношения двух имён закрыт: третье поле границы и четыре факта подстроки (fac342b)
• Числа словаря догнали дерево: восемь поручений, девятнадцать вариантов, и предсказание в plan.flang сверено с тем, что вышло (6f867e2)
• Приложение живёт и в настоящем браузере: 6 сверок из 6, 111 тактов часами (b417faa)
• Служба работает ПО СЕТИ: шестнадцать связей через настоящий сокет, коды сошлись с прогоном через значение все шестнадцать (23110e6)
• Область на накопитель свёртки: 8 МиБ вместо 710 на четырёх тысячах, ценой 1,37 раза по времени (6f3faed)
• Сеть, которой ждут: три поручения, один отклик, и служба сокращателя переехала на сокет без единой правки в самой службе (940fdda)
• Приложение в браузере: 16 тотальных функций на flang, 31 пример, 0 упавших (7595f62)
• Отношение ДВУХ ИМЁН вписано: у подстроки не хватало ровно одного факта из четырёх (d80cc71)
• Словарь ввода-вывода узнал экран: было 5 поручений и 7 откликов, стало 7 и 10 (f7bead5)
• Перемерено на стволе: пять команд на месте, --proof печатает, память врала в 410 раз (b8011b3)
• Близнец кладёт и вторую отметку: непустота доехала до дерева, 144 программы из 148 размечены как эталон (39266f7)
• Ведомость точки раскрутки перемерена: таблица врала вдвое, а команду run не знала (5627441)
• Смешанные письменности сняты нацело: 228 → 0, невидимая беда убрана первой (5bdb9ba)
• Точка раскрутки перепечатана под новый близнец типизатора: 8 017 599 байт, семь файлов (8b9351f)
• Корпус спрошен: 18 мест из 213, и настоящая причина отказа названа — она не сторож, а ТИП (34a6d5d)
• Типизатор близнеца отдаёт доказанное число на узел: отметка была, класть её было некому (4822a42)
• Сторож имён: правило про имя проверяется прогоном, корпус сверяется поимённо (663c570)
• Сторож чисел успокоен: «122 строки» рядом с именем файла читалось как число строк файла (aff49d2)
• Ведомость корпуса сведена с деревом: сорок восемь доказанных, четыре новые строки службы, 57 из 57 (c774c02)
• Цена четвёртого хода перемерена на трёх оставшихся: препятствие не подготовка, а проводка (fa5e4a4)
• JSON вынут из ветки: он требует слова «приписать», которого в этом дереве нет, и ломал 230 проверок библиотеки (8160bb8)
• Каталог службы описан числами: 1 258 строк, 7 утверждений, 5 закрыто ядром, 4 недостачи с ценой (5439c23)
• Служба работает СЕГОДНЯ: запрос из файла, ответ в файл, два поручения, 243 из 243 (639ee1c)
• Незавершаемость в планировщике: запас кончился у одного, служба жива — 243 из 243, сетка 200 семян (7cb98c6)
• Ещё пять мест номера доказаны корпусом: 7 из 214 стало 14, и оба узора правки названы (83c781a)
• Верхняя граница номера ВПИСАНА В КОРПУС: два места доказаны, и цена правки названа (f5321a6)
• Служба целиком: байты пришли — байты ушли, шестнадцать запросов подряд, четыре из них злонамеренных (532054c)
• Исход службы объявлен типом, и три утверждения о нём закрыты ядром: 4 из 4, ноль на веру (bf1731f)
• Хранилище ссылок: 12 тотальных функций, 17 примеров, ни одного места в памяти (a09494c)
• Мирская половина HTTP, JSON и время подтянуты в дерево: 2 596 строк библиотеки под настоящую службу (ded8e96)
• Три сторожа сведены после пары бинарника (1458c6b)
• Долг столбца снят из «Долгов», а вход с эмодзи заведён и в stdlib: числа свода пересчитаны прогоном, а не перенесены (7d6427b)
• Точка раскрутки перепечатана под столбец в единицах UTF-16: две единицы трансляции, +4853 байта (2b4f503)
• Столбец близнеца лексера переведён в единицы UTF-16: десять расхождений с эталоном закрыты, вход с эмодзи стоит в корпусе сверки (e62f07b)
• Четыре следа слияния в проверках закрыты: правил пять, и своды пересчитаны (b4fbddf)
• Близнец расходился с эталоном СТОЛБЦОМ отказа — и поймал это краевой случай (a909d8c)
• Длинная строка отказа разложена, числа прозы догнали: 4507 → 4511 (0bf3f0e)
• Два поколения без Node сошлись: flang₂ печатает ровно то же, что flang₁ (8d5e555)
• Дыра в flang run названа: ключ --index-base туда не доезжает вовсе (70c93fe)
• Числа прозы про парсер догнали дерево: 4434 → 4507 и 6947 → 6981 (8953394)
• Сверка AST всего корпуса нашла ЕДИНСТВЕННОЕ расхождение — и оно в тексте отказа (d5a8d38)
• Точка раскрутки перепечатана: близнец парсера тронут — артефакт догнал (59d882d)
• Переходный уклад закрыт: SPEC называет слово, а ключ ставит базу только молчащим (e168890)
• Близнец слова на flang, подделки и починка двух изъятий после слияния (8ea6190)
• Проза в POLY.md пересчитана: две строки таблицы разошлись с деревом на 7 и 3 (0d8c92f)
• Слово в языке: элемент начиная с 0 объявляет базу номера в самом файле (0b1e901)
• Заслон печати у близнеца: сверка заговорила и назвала место, которого я не ждал (de27451)
• Оба ключа доведены до близнеца связывания: неподвижная точка 25 из 25 (1c9a1f8)
• Близнец границы номера закрыт: читатель и база одним шагом, и сверка получила голос (6956ef5)
• SPEC: дверь договора записана и за близнецами, а не только за эталоном (59defb1)
• Число строк близнеца C в POLY.md пересчитано прогоном: 3858 → 3956 (d1e9989)
• Отмена знания при перевязке имени в близнеце: 14 мест связывания, три места сужения нетронуты (3ea18a0)
• Точка раскрутки перепечатана: bootstrap/ снова та печать, что дают исходники (094d0cc)
• Дверь договора доехала до близнецов Java, C#, Elixir и JavaScript: восемь из восьми (a581c58)
• Близнец границы номера начат: поле и сбор написаны, и третий замер объёма снова оказался меньше (1440e67)
• Помеха семи целям названа числом: столкновения имён по каждой, 2…309 (a226e62)
• Дверь договора доехала до близнецов Rust и Python: четыре цели из восьми (c578416)
• «Одно слово на функцию» опровергнуто замером, зато найдена и закрыта настоящая дыра (86c8492)
• Указатель библиотеки перепечатан, а охват ядра дорос до сорока восьми: седьмой доказанной в библиотеке стала «Сколько заголовков» (e04e366)
• Дверь договора доехала до близнецов C и Go: две цели из восьми (836d2ca)
• Объём долга близнеца поправлен по дереву: имена границы кладутся в «Вид отрезка», а не в «Вид числа» (743aa1a)
• База номера стала свойством ПРОГРАММЫ: нестрогая граница заработала, 2 места из 214 стали 7 (eb5e4bb)
• Кеш убран из рабочего пути за явное согласие: потолок JavaScript не пробит (4f93a6d)
• Форма из справки заработала: --function «Имя» принимают обе реализации, а не одна (e016093)
• Числа строк в прозе подтянуты за новыми файлами: сторож счёта снова чист (34cde47)
• Указатель перепечатан, числа прозы сведены со сторожем (ad47552)
• Заголовок оболочки не расширен: каталог печати заводит человек, а не emit (e33eaa8)
• Транслит из имени каталога убран: docs/rukovodstvo → docs/guide, 35 ссылок в 10 файлах переписаны (b11e7e1)
• Предусловие в библиотеке снято печатью: восемь целей дороже одного утверждения (8f5f6b2)
• Замер выигрыша от кеша записан числом рядом с кешом, и число неприятное (3d7b791)
• Зазор ведомости назван числом в дереве: 33 из 37 знак в знак, 4 — в сторону «сказал меньше» (30ae079)
• Числа README и обзора догнали дерево: библиотека выросла до четырнадцати модулей, корпус восьми целей — до 96 программ (f5d4b2a)
• Плагин asdf стало откуда ставить: репозиторий заведён, а расхождение копий стережётся (fb53566)
• Числа прозы догнали дерево после правки: 7048 строк src/types.mjs вместо 7040 (0e1d768)
• Именной верх переносится через числовое сужение: вложенный если перестал отнимать доказанное (ee87a3d)
• Именная дорога корпусом НЕ проверена, и близнец назван долгом с объёмом (86ff939)
• Класс номера измерен поимённо: свод 279 у 195 не сдвинулся, и причин шесть (2284db8)
• datetime.flang: 24 функции, 77 примеров, ноль сторожей в рантайме (8f0439d)
• Замеры библиотеки пересчитаны прогоном: 259 функций в четырнадцати модулях, индукции доступны 65 — впервые с работы над списками вырос и счёт по суммам (dfef247)
• Бинарник получил check --proof и test; ядро в дороге проверки отвергает подделку тем же кодом (068f4ff)
• Печать в C въехала в двоичный: шесть файлов из семи байт в байт без Node (0d4d9d3)
• Корпус прогнан по модулю: 54 входа сошлись, обрезки целого запроса по одному байту все до единого «неполон» (1320dcd)
• Утверждения json: высказано 8, ядром закрыто 5 (df7e9f1)
• Кеш вердиктов ядра лёг под адрес содержимого, и на слово ему не верят (ab31126)
• Верх, выраженный ИМЕНЕМ: границы номера доказываются, и заслон печати назван (ee0bed6)
• Печать json и корпус зелёный: 91 из 91, и корпус нашёл ошибку (8a04b6d)
• Печать ответа и запроса: Content-Length считается по телу, а не берётся из заголовков — расхождение длины с телом это шов, по которому вставляют чужой запрос (b3ff394)
• Разбор запроса целиком: три исхода вместо двух, и «неполон» отдельным вариантом — обрезанный запрос ждут, а не рвут связь (f4d16d6)
• json.flang: разметка и разбор стопкой — 31 функция, 60 примеров, всё чисто (7da938c)
• Ядро, примеры и ведомость доехали до точек входа компилятора; граница входа у прогона (9259a2b)
• Процентное кодирование и адрес: кодирование полное, раскодирование доводит до знака только печатные ASCII — обратного моста к «код символа» в языке нет, и предел назван, а не обойдён (39b699c)
• Адрес определения считается от нормализованного разбора: четыре поверхности дают один хеш (a29eddb)
• Чистая половина http начата: куски строк, сравнение имён без регистра и целое из десятичной без знака — отрицательная длина тела не число, а нападение (16cfc1f)
• Список asdf состоит из версий, которые ставятся: релиз без архива в него не попадает (1c41ffe)
• json.flang: значение, знаки и число из текста — 15 функций, чисто (2a0b401)
• Точка раскрутки перепечатана: перебазис оставил её на 3431 функции против 3439 в дереве (e655a49)
• Команда npm run build, которой нет, убрана из обоих README и ещё из шести файлов (e5882c1)
• Восемь транслитных имён в fspec переименованы английскими словами (9930d16)
• Перебазис на настоящий ствол: разошлось 3 из 275, ствол пришёл красным на 8 (87cafd7)
• Близнец сетки починен после переименований двоичного; ведомость и долги сведены (b6b3e78)
• Дерево сведено после двух слияний: раскрутка, ведомость, долги и потолок (bfa96b4)
• Откат слияния work/totality-hole отменён: препятствие, из-за которого он был, снято (5dcdace)
• Ядро доказательства въехало: три предела перемерены, рост оказался квадратичным (2e7fe72)
• Цена договора в печати названа числом: «ноль байт» было верно и было дефектом (aebc7ec)
• Близнец горячей замены откачен; ведомость переснята, долг и потолок выправлены (5a7a460)
• Договор доехал до двери C# и Elixir: восемь целей из восьми (fba8e3b)
• Договор доехал до двери Rust и Java: шесть целей из восьми (6c088c7)
• Договор доехал до двери Go и C: четыре цели из восьми отказывают тем же кодом (d15b127)
• Договор доехал до двери Python: вызов по имени проверяет требует (00e72c1)
• Договор доехал до границы напечатанной программы: JavaScript отказывает тем же кодом (3c8620e)
• Ядро отцеплено от замыкания: три бюджета не пускают, названы числом; 36 имён остаются (5269b86)
• Слияние work/totality-hole откачено: требует не доезжает до печати (574094e)
• Ядро доказательства втащено в двоичный: 36 переименований, стена оказалась в памяти (30b5c69)
• «Состояние» точки входа раскрутки названо в той же форме, что у прочих долгов (f013022)
• Третий шаг: корпус честные предусловия НЕ выдержал, и препятствий два (66c39a4)
• Сторож чисел чист: одиннадцать чисел прозы пересчитаны деревом, а не подогнаны (6272b76)
• Проза сведена с деревом прогоном: сторож чисел чист, было 75 расхождений (c1267dd)
• flang run появился в двоичном: программа считается без Node и без «cc» (15bf721)
• Два честных требует в stdlib: свод сдвинулся 279 → 277, и цена измерена (e015095)
• Числа «Долгов» и журнал догнали слияние: два сторожа снова зелёные (628bdb2)
• Два числа прозы, разошедшихся от правки, догнали дерево (98db0a0)
• Восьмой близнец доучен форме «приписать»: 101 программа из 101 вместо 94 (781e88c)
• Довод про чтение требует типизатором записан в SPEC; числа прозы догнали дерево (1d98aba)
• Числа собственных страниц сайта сведены с измерителем: «семь языков» стало восемью, и заведён сторож на 17 чисел (ef4568b)
• требует читается фактом в типизаторе: сторож у голова снят по-настоящему (8074d09)
• Числа страницы поверхностей взяты под сторожа: 16 фраз собираются из прогона и обязаны найтись дословно (cbdc412)
• Формула Homebrew перестала врать: ссылка отдаёт 200, а sha256 сверен со скачанным (2a293ce)
• Словарь языка заведён печатью из таблицы поверхностей: 148 понятий, сторож краснеет двумя способами (c25d482)
• flang/src/proof.mjs стёрт: ведомость доказательства осталась только на flang, 1 300 строк вон (1b2ac67)
• 84 заметки базы знаний переименованы: транслит уступил английским словам (3a6f55b)
• Имена файлов и адреса страниц переведены с транслита на английские слова (5961343)
• Вычислитель втащен в двоичный: помеха названа числом — три столкновения имён (7f95df5)
• Довод про четвёртое правило записан в SPEC, числа прозы догнали измеритель (ac0e344)
• Шапка близнеца замены выправлена: долг назван там, где он есть, и красный список сверен именами (8fedd1d)
• Числа корпуса и утверждения догнали форму: свёртки в корпусе больше нет (9fb1491)
• Сверка близнеца замены влита: 57 пар сетки сошлись побайтово, три изъятия краснеют (61e0c72)
• Словарь между спеками встроен в flang check: три порчи краснеют своими кодами (2d40dc4)
• Каталог недостач и рантайм Elixir догнали форму: три места, где ветка отстала (a03ff94)
• Правило «цель есть допущение» (Γ, A ⊢ A) — на обеих сторонах разом (0d9f3c2)
• Ведомость самоприменения выправлена: строка io.mjs больше не «не начат» (39a127b)
• Проверка планов встала на flang: 18 случаев корпуса, 4 порчи из 4 краснеют (2c0583a)
• Близнец горячей замены собран: три условия из четырёх, связывание и типы чисты (1ea0748)
• Сторож четырёх поверхностей покраснел на цитате — цитата снята (3c0b6ae)
• Три рантайма ветки чинены под нынешний main: приписать собиралось не тем API (c212afc)
• Числа прозы догнали дерево: 21 расхождение, внесённое вливанием, закрыто (891c66d)
• Тень программы перенесена на flang: 204 тени сверены побайтово, 161 Мб (240fe33)
• Семь близнецов доучены форме: зазор между эталоном и близнецом закрыт (ed99f5b)
• Требование до кода: требует у левого края, ноль новых слов (9e280d1)
• Версия набора правил 9, и число впервые сдвинулось вместе со счётом правил (522444d)
• Сторожа числа правил пересчитаны: правил ЧЕТЫРЕ, и это стоит списком (24e7ba8)
• Близнец догнал: правило 4 написано и на flang, и подделки под него отвергнуты (0b78b6c)
• Четвёртое решающее правило: порядок по построению, граница — ТЕРМ (f377d57)
• Подделка на четвёртый ход написана: замкнутая посылка, дающая «нет» (53f9bca)
• Проза о восьмом близнеце пересчитана прогоном: 3268 строк было приговором, 3667 стало делом (0b6de04)
• Сверка восьмого близнеца зелена целиком: 101 из 101, 44 из 44 меры, 10 из 10 процессов (c02bc00)
• Числа улики пересчитаны счётом строк, а не длиной разбиения: 1768 и 20 038 (01478fa)
• Словарь действий конкурентности считает flang: 162 программы сверены побайтово, расхождений 0 (6a05890)
• Четвёртый ход ядра перенесён в близнеца: вычисление замкнутой цели (4912ba4)
• Близнец печати в JS догнал эталон: 101 программа из 101 совпадает побайтово (ce77628)
• Пятнадцать помощников рантайма доехали в близнеца: стек под объявленный предел и вид «добавить» (3ecc7fd)
• Множество отказов считает flang: 1358 функций корпуса сверены побайтово, расхождений 0 (7bb77ac)
• Черновик близнеца печати в JS снят с неслитой ветки: замер выбрал догон, а не переписывание (c6db14b)
• Проза догнала дерево: контракт слоя назвал шаг 8, четырнадцать чисел пересчитаны измерителем (6832cf9)
• Служба на flang и 26 проверок к ней: подделка краснеет на 1724 чередованиях из 6000 (0df70ad)
• Хозяин у службы: одна цель печати из восьми исполняет поручение, семь отказывают названным кодом (4b87bf0)
• Седьмое действие процесса: поручение выдаётся, отклик приходит сообщением, а видов отказа как было десять (657f058)
• Числа сторожей сведены до конца: частичных форм 846, непустотой снято 363, «вес» доказывает 45 (227dc02)
• Числа корпуса сведены с деревом после прибавки языкового сервера: функций 6 855, утверждений 149 (73cbea5)
• Языковой сервер получил близнеца на flang: протокол, документы и диагностика сверены с эталоном знак в знак на 40 сообщениях (70f1ebb)
• Таблица ключевых слов близнеца лексера сведена с образцом порядком: 138 фраз из 625 стояли не на своём месте (564c9be)
• Библиотека и примеры больше не платят длиной списка за приписывание в начало (ff0c2d7)
• Список наращивается с двух концов: приписывание в начало стало встроенной формой и напечатано во все восемь целей (c486f90)

Ещё 357 правок языка снаружи не меняют.

0.5.0 — 18 августа 2026

• Словарь между спеками стал проверяемым: имена отображения сверяются с обеими спеками (ee69bb7)
• Причины двенадцати сеток списка и четырёх сеток ВПО измерены попыткой (58883e1)
• Семь мёртвых функций вынуты из близнеца: имя без зова — обещание без исполнения (ab00383)
• Числа сверки вписаны в шапку близнеца: 177 вызовов, 160 решает сам (ff98b88)
• Названо, чего не хватило «неделимому остатку»: делитель — имя, а не литерал (f4b28ab)
• Причина расхождения синонимов названа счётом: спрашивает одна сверка из семи (6a558e4)
• Довод «builtins.mjs не переписывается» проверен прогоном: он устарел, файл уже переписан девятью частями (26386d0)
• Три утверждения «Кратчайшего пути» переехали из сетки в доказанное ядром (461382c)
• Сверка на 177 вызовах зелена: расхождений 0, близнец решает 160 из 177 (6451f2a)
• Доказано «удвоенное неотрицательно»: теорема в пять строк, ноль строк ядра (dfc4e77)
• «the Fibonacci step is non-negative» — та же теорема на английской поверхности (78e3101)
• «шаг Фибоначчи неотрицателен» переехало из сетки в доказанное ядром (0911f0e)
• Теги программы на flang: список случаев диспетчера перестал держаться на JavaScript (f39fef1)
• Близнец командной строки разбирает вызов: тридцать ключей, четыре отказа до работы (6953da3)
• Противоречие двух спек на flang не ловится ничем: прогон дал код выхода 0, и заведён сторож, который краснеет (dc98f68)
• Граница чистого и эффектов в командной строке измерена: 258 строк из 700 (2589478)
• Вычислитель-близнец расклеен трёхсторонним слиянием: обе стороны целы (bcf6044)
• Три сторожа и вычислитель-близнец расклеены: моё слияние сложило все стороны разом (e1e73c1)
• Числа прозы сведены с деревом после шести слияний: 63 из 63, правлена проза (4afc76c)
• Точка раскрутки перепечатана после замера стека в wasm (9e253ac)
• Число строк склоняется: 33 921 это «строка», а не «строк» (909aa97)
• Точка раскрутки перепечатана после всех слияний (85d1da7)
• Точка раскрутки перепечатана после слияния монады: печать, а не текстовое слияние (6b78689)
• Заголовок Д1 больше не спорит со своим же абзацем: «три захода» это заказ, «девять» это итог (d38dd01)
• В4 переставлен на своё место: раздел В3 больше не разорван посередине (39d067a)
• Цена лишней ветви в горячем цикле вычислителя измерена: знак отрицательный на шести прогонах из шести (24fc942)
• Порог окупаемости пула ИЗМЕРЕН: считали K больше шести, вышло K = 1, а настоящий порог — один готовый процесс на поток (c9013c4)
• Очередь готовых стала деревом рангов: 207 с → 13,8 с при миллионе одновременно готовых, журнал побайтово тот же (8705369)
• Потолок задержки есть: снятый пробег доигрывается с места, и самый дорогой падает с 4418 витков до 512 (1303e55)
• Объявленный предел глубины в wasm стал пределом: было молчание сторожа и смерть вкладки на глубине 60, стало 7 474 кадра и текст эталона (7bd8800)
• Журнал вливаний вышел на сайт: 138 вливаний, у 105 названо сдвинувшееся число, страниц стало 103 (a9e95f7)
• Ограниченность считает flang: 18 893 функции корпуса сверены побайтово, расхождений 0 (8423ce6)
• Точка раскрутки перепечатана после слияния седьмого слоя: 8 220 897 байт, сверка 24 из 24 (eb6b71b)
• Числа прозы сведены с последним замером: 258 из 263, изъятий 29 (2211e1f)
• Сверка связывания названа прогоном: 260 программ, 21 129 объявлений, расхождений 0 (d28ea5c)
• Изъятие слоя поверхностей записано числом: снят вызов — красно с первого случая (5beac91)
• Числа корпуса пересчитаны, а не подогнаны: 6484 функции, 364 места непустоты (9351e8d)
• Печать самоприменения перешагнула сторож шагов: доказано, что не перебором, и лимит поднят (3667f02)
• Принцип по свёртке перенесён: три формы тела закрыты, разошлось 5 из 262 (9656e5b)
• Цена разбора корпуса названа верно: 26 минут против 2, а не против 40 секунд (1c52ed0)
• Числа прозы пересчитаны после подрезки слоя: 1308 строк, 135 функций, 28 обычных (8049501)
• Один тег и тот же тег с захватом разведены по двум диспетчерам: проверка и названный долг (d8e33b1)
• Точка раскрутки перепечатана, а сверка достижимости получила семь дурных наборов вместо пустого корпуса (0b65388)
• Числа корпуса сведены с деревом после фазы 4: 35 функций близнеца, сторожей ноль (56b5b19)
• Числа прозы сведены с выросшим деревом: шесть записей, сторож поймал все шесть (f741138)
• Проза сведена с деревом: седьмой слой назван в четырёх документах, четыре числа пересчитаны (9215298)
• Равенство морфизмов и естественность квадрата считает flang: 231 программа сверена побайтово, расхождений 0 (bbbe72e)
• Четыре поверхности диагностики закрыты: цитата говорит на языке файла, 0 расхождений из 186 (1c2d7bf)
• Сличение по вызову перенесено в близнеца: разошлось 6 из 260 (823c40b)
• Связывание вынуто седьмым слоем: сверка выросла с 13 синтетических наборов до 232 программ, расхождений было 23 (678eb34)
• Пробел разбора закрыт последним словом: 148 слов из 148, в монаде разворачивается (f900156)
• Разбор цели по условию перенесён в близнеца: разошлось 7 из 257 (4dfe57c)
• Квадрат связи модулей считает flang: 231 программа корпуса сверена побайтово, расхождений 0 (f8ee781)
• Цена четвёртого хода переписана прогоном: три программы зазора из четырёх считают замкнутую цель за 875–1395 мс, четвёртая упирается в другой файл (3b876dd)
• Разворачивание монад вынуто отдельным слоем: парсеру оно стоит 90 функций, а не 1154 (dfbd5fe)
• Подготовка программы у близнеца-вычислителя удешевлена в 15,5 раза: 1074 функции считаются за 792 мс вместо исчерпанного предела в 40 000 000 витков (6282a6a)
• Захват части аргументов работает обеими сторонами: 47 случаев из 56, которых приставка не брала (fb33469)
• Числа дерева сведены с измерителем после трёх переносов: правлена проза и ожидания, сторожа не тронуты (864a34d)
• Долг разборщика, которого нет с 15 августа, снят из четырёх шапок и двух спецификаций: запрещённых слов осталось одно из девяти (94d9c1e)
• Зазор самоприменения сведён прогоном: 236 из 250 и 14 поимённо вместо 237 из 249 и 12, разбирается 147 слов из 148 (180f668)
• Порождение процессов есть, а стен осталась одна из трёх: две заметки базы поправлены прогоном, копия в /srv перестала ломать ссылку (7ca513a)
• Каррирование замерено до работы: фаза 4 упирается в одно правило, написанное дважды (d67acaa)
• Принцип по отрезку «нат» перенесён: носителей стало два, разошлось 7 из 255 (f3cdc08)
• Два долга ведомости в SPEC самоприменения закрыты и заменены обратным утверждением: близнец знает все шесть слов и все девять видов законов (5893037)
• Ведомость доказательства вышла из рабочего пути на JavaScript: flang check --proof считает слоем на flang, эталона в пути нет (ba78881)
• Теорема держится у библиотечной функции: связанный AST 102 из 102 вместо 101 (86bf881)
• Носители обещания сверены побайтово на 234 программах вместо восьми, расхождений 0 (cc6f70c)
• Числа прозы сведены с выросшим близнецом ведомости: правлена проза, а не сторож (3104d20)
• Гипотеза «дано» типизируется обеими сторонами: три улики из трёх отвергнуты (5b68cbf)
• Тихий конфликт двух веток найден прогоном: -flto увидел незаполненный итог прогона (ccd7248)
• Связывание на flang научилось нести теорему входного файла — как эталон (1a5bfe4)
• Цена четвёртого хода измерена, а не оценена: 12 счётов из 43 зовов, подготовка не кончается на 1074 функциях (d8f4e58)
• Точные десятичные и правило остатка перенесены: разошлось 10 из 252 (ea9486c)
• Точка раскрутки и проза догнали многоядерный планировщик: правлен пересказ, а не сторож (74ad18a)
• Ведомость на flang печатает утверждения, категорию, связь и пять свойств: 226 программ дерева из 226 сходятся с эталоном побайтово, было 0 (78734f7)
• Начальная алгебра встроенного списка перенесена в близнеца: разошлось 11 из 251 (deb945d)
• Готовый процесс кладут на СВОЙ склад, а не на склад по остатку от номера (38895bc)
• Числа прозы сведены с деревом после слияния: правлена проза, а не сторож (f56409b)
• Изъятие показало дыру в наборе: замок процесса не держал ничего — теперь Р6 (cb7054b)
• Стенды замера умеют оба режима: поле «workers» в mera.sh и новый poyadram.sh (d9d6f2f)
• Зазор с близнецом назван поимённо, а не расширен: два расхождения из трёх стоят в списке, третье закрыто переносом текста (7e50f41)
• Корпусная сверка шести целей пошла по ветви отметок и нашла там сломанный список Elixir (aadfd1f)
• Заметка в каталоге linguist названа точно: заявка на flang уже написана, а не «ещё не приехала» (ab0c5da)
• Сверка тега вернулась в напечатанный код: прогон корпуса нашёл, где доказательство опиралось на ложную посылку (d31a635)
• Последние четыре места, называвшие уехавшее, приведены к дереву (fa14b4b)
• Ломоть пробегов отвязан от пачки: потолок был в общем замке, и это измерено (ac13526)
• Три заметки в базу знаний и поправка к четвёртой: как разнимать проекты, не потеряв проверку (5debace)
• flang-lsp перестал молчать на непонятом доводе: команда, отвечающая кодом 0 и ноль байт, неотличима от сломанной (ee9ea8a)
• Старый проект FTS вынесен из репозитория: 357 файлов, 180 755 строк — и всё, что его называло, приведено к дереву (fdfb0aa)
• Найдено зависание на тридцати двух потоках, и оно было не в скорости (aea6649)
• Зависимость сличения по вызову названа заранее, чтобы её нельзя было сломать молча (c006085)
• Отметка анализа перестала считаться частью написанного: ведомость вернула 60 утверждений из 138 (35e0509)
• Две поправки честности: сличение по вызову не берёт допущение индукции, а разбор по условию не берётся за связыватель (5d564c6)
• Чтение .fts стало внятным отказом, а не падением: свой код, указание, где взять убранное, и закрытая дыра рядом (10aacac)
• Побайтовая сверка с близнецом сохранена: пятый ход включается доводом, как четвёртый (1ccc24c)
• Проверка типа не печатается там, где тип доказан: арифметика быстрее в 4,9 раза, всё вместе — в 1,6 (2854d2b)
• Ядро научилось цепляться за три формы тела: условие, свёртку и вызов (43e61f2)
• Близнец обязательств стал истиной, а эталон — вторым мнением: отношение перевёрнуто там, где оно уже настоящее (c7b2ae1)
• ThreadSanitizer нашёл гонку на признаке остановки — признак ушёл под замок (eace078)
• Рабочий режим планировщика: потоки берут процессы, а не пробеги (e771cff)
• Обязательства в рабочем пути считает flang, а не JavaScript: мост переехал в дерево (e5c4be2)
• Шесть файлов, от которых зависят все восемь целей печати, переехали в flang: не копия, а перенос (4114962)
• Межмодульная оптимизация включена по умолчанию: напечатанный C стал быстрее в 1,14 раза (c903983)
• Языковая полоса GitHub: сырьё замеров исключено, а про .flang сказана правда (a6761f4)
• Сайт документации собирается из docs одной командой, без единой зависимости (ab948f3)
• Документация разложена по назначению: руководство в docs/rukovodstvo/, у docs/ появился указатель (74a4832)
• Ведомость пересчитана на собранном дереве, и проза догнала её числами: 6429 функций, 4893 тотальных (17d6853)
• Близнец ядра доказательства догнал эталон на 242 программах из 249, а остаток зазора назван поимённо (7cc5804)
• Сырьё замера отсечено от корпусов одной строкой: 41 красная проверка была не про язык (d9ff37c)
• Ведомость пересчитана ОДИН раз на собранном дереве: 6383 функции, 4868 тотальных, 138 утверждений (676c662)
• Спецификация назвала четвёртый ход, его три условия и долг: у вычисления близнеца на flang нет (7e931a2)
• Замкнутая цель стала вычисляться: тот же ход, каким закрывает случай «по примеру», позван из «свести» (4011dae)
• Три леммы об алфавите: регистры не пересекаются, обе половины начинают имя (14cf309)
• Две леммы о чужих знаках в имени: один символ и объявленный пробел (4de7a81)
• Ещё одна цена переезда, и снова измеренная: связывание на flang теряет теорему (94a45e8)
• Пять лемм об алфавите идентификатора C и о приставке помощников (b3eaae4)
• Долг переезда закрыт наполовину, и вторая половина оказалась платной (ae711fc)
• Дерево догнало правки: точка раскрутки пересобрана, восемь чисел прозы пересчитаны, сверка ведомости узнала пятый источник законов (92aa3b1)
• Числа корпуса догнали близнеца: 5775 функций, 4406 тотальных, 4200 без проверок (ac79f62)
• Монада перестала пропадать при связывании: латентная дыра того же класса закрыта, пока её никто не открыл (8e956f4)
• Проверка предела запроса переехала под ifdef: без процессов она никому не нужна (bdc54c3)
• Контракт теорката получил главу про связь модулей — вместе со списком того, чего этот слой не проверяет и не будет (1581aa4)
• Третий отказ порождения записан в контракт и в карту, счётчик строк пересчитан (e38555f)
• Вычитка планировщика нашла пять мест: одно портило доставку, четыре были заряжены (6409d9d)
• Вердикт нарушенного закона назван словом эталона: «violated», а не второе слово о том же (a530d59)
• Три модуля с тремя взглядами на один заказ легли в дерево: связь между ними стала проверяемой, и три обычные ошибки её ломают (7ff6895)
• Спецификация назвала починку близнеца и цену слепой сверки (6e96787)
• Близнец начальной алгебры догнал починку захвата, и сверка перестала быть слепой к ней (7c6c5f7)
• Две леммы, закрывшие две записанные недостачи: длина списка и глубина дерева (bd711f1)
• Разборщик на flang догнал эталон: перевод данных на объекте функтора разбирается обоими побайтово (7aaf7f7)
• Два новых красных закрыты, и второй из них оказался дырой, которая была здесь всё время (50c9581)
• Слияние с main прошло, и слияние показало три вещи (9ed03d8)
• Спецификация назвала шесть дыр за сутки, захват подстановки и новый охват сторожа (a988c07)
• Третья стенка измерена, а не оценена: порождение открыло дверь, которой не было (713a82d)
• Сортировка вставками досчитывает там, где раньше отказывала: 1500 элементов под пределом 8 ГиБ (37b5639)
• Сторож смотрит на ВСЕ утверждения корпуса, и первым делом нашёл два ложных в витрине (12bfe59)
• Двойники стендов собираются скриптом: «а что было бы» стало повторяемым (d477ccd)
• Близнец ядра догнал правило умножения: слитая ветка писалась под эталон, который с тех пор уехал (8d7fc6b)
• Подстановка перестала захватывать чужое имя: «доказано индукцией» о лжи закрыто (9689a37)
• Связь модулей перестала быть сличением имён: у объекта функтора появился перевод данных, и квадрат считается на сетке (cbbd42e)
• Округление названо своим именем, а минимум и максимум взяты как честный носитель — находка соседней ветки, проверенная своими законами (e568ce0)
• Незаконченное сохранено на обрыве лимита: работа прервана посреди шага, проверок не было (b535718)
• Незаконченное сохранено на обрыве лимита: работа прервана посреди шага, проверок не было (05207a1)
• Незаконченное сохранено на обрыве лимита: работа прервана посреди шага, проверок не было (1241a67)
• Четвёртый прогон примера: занятое имя роняет сервер, и это сверяется побайтово (4f1bcab)
• Контракт, реестр недостач и числа корпуса догнали пять свойств (97d2952)
• Две леммы об ограде таблицы ключевых слов: разрез попал на границу пары (5905ea0)
• Сторож длины дерева пересчитал строки: 24 379 → 24 673 (27341fc)
• Сторож проводом узнал шестое действие: «породить» на проводе такой же вариант (1ee68f7)
• Число строк компилятора в self/SPEC.md догнало дерево: 24379 стало 24745 (ce5cdc3)
• Спецификация назвала четвёртый связыватель у сторожа захвата и общее у четырёх дыр (4f1da99)
• Три леммы о ширине символа в UTF-8, и одна выдуманная ложь по дороге (20f8bca)
• Замер ПОСЛЕ теми же стендами: три таблицы, два двойника и один опровергнутый довод (5f5626b)
• Найдена своя дыра того же класса: сторож захвата имени отстал от языка на связыватель (28e9ca1)
• Монотонность: разрешение кешировать — и первое место, где сломанное свойство останавливает зависящее от него (2f0f878)
• Контракт и карта догнали порождение: Б1 и Б2 закрыты, «породить нет» вычеркнуто (f451412)
• Частичный порядок: три закона порознь, и антисимметрия — та, без которой расхождение реплик становится законным (9f05f49)
• Спецификация слоя назвала сторожа на класс и то, чего он не покрывает (1e2d77c)
• Дистрибутивность: одну строку заказа можно разбить на две, и это теперь разрешение, а не обещание (f6bc341)
• Точка раскрутки перепечатана: близнец лексера узнал девятое слово (171880d)
• Две леммы о регистре латиницы: поднятие и правда обращает опускание (dd65d62)
• Коммутативность: моноид впервые называет третий закон, и недостача из cat/SPEC.md закрыта (5f5bbdb)
• Две леммы о списке русских окончаний: длинные впереди, пустых нет (c209cae)
• Отказ и вывод типа перестали расходиться: деление конечного положительного на вес законно в обоих (7cb887e)
• Две леммы о синонимах встроенных форм: цель есть и разрешение в один шаг (d111f81)
• Идемпотентность: язык впервые умеет сказать «повторить безопасно», и это разрешение выдаётся, а не подразумевается (01cc4d4)
• Числа сверок в спецификациях догнали дерево: 195 и 201 программа, изъятий двадцать пять (becea64)
• Лемма о знаках полной ширины: двойники стоят парами (626e3ef)
• Четыре леммы об алфавите лексера: парность регистра и граница ID_Start (aa2062b)
• Цена типа названа числом: 21 функция корпуса из 139 становится доказуемо неотрицательной (120f1fa)
• Две леммы о транслитерации имён для C: на выходе только буквы идентификатора (f147801)
• Куча процесса покупается полукилобайтом, а не 64 КиБ: вторая стена замера (cc2cebe)
• Две леммы о таблицах встроенных форм для C: помощник без арности не спрячется (d0f3fd2)
• Три леммы об экранировании JSON: обратная косая и правда стоит первой (5e605a8)
• Счёт строк эталона в self/SPEC.md догнал дерево: 25044 вместо 24379 (818416e)
• Зазор близнеца до эталона на main измерен прогоном: решение расходится на четырёх программах, текст ещё на шести (4fc24a3)
• Отрезок [0,+∞] стал типом «вес»: три действия разрешены, четыре отказывают с предъявленной парой (8f90221)
• Пример: сервер заводит обработчика на каждый запрос и переживает его смерть (7cfb69d)
• Рантайм C: указатель имён вместо перебора, и таблица процессов, которая растёт (60fafee)
• Порождение в эталоне: имя даёт родитель, потому что вернуть его нечем (bacbb23)
• Английская поверхность «Фибоначчи шагом» догнала русскую, и сверка пар научилась именам утверждений (a83440c)
• Две леммы о списке длин ключевых фраз: порядок и дно жадной склейки (b8f21e6)
• Три леммы о таблицах типов FTS: цепочка из двух переводов не рвётся (954d646)
• Носитель моноида читается по имени уточнения: до этой строки не собирался ни один моноид над «нат» (f47a535)
• Охват ядра вырос на две функции, и обе получили утверждения там же, где стоят: 33 высказано, 31 доказано (9aaf00c)
• Три леммы о знаках лексера FTS: одиночный знак и правда один символ (15e82fb)
• Три леммы о метках связывания: знак вопроса и несовпадение (753a6b4)
• Три леммы об ограде перечня точных имён: без неё крайние имена не находятся (f615d8a)
• Числа корпуса и проза догнали предусловие (03908f1)
• Точка раскрутки перепечатана: 447 обёрток компилятора получили область на вызов (12f81cd)
• Арена в цели C научилась откатываться: сортировка слиянием 4000 чисел берёт 3,5 МиБ вместо 1655 (e342156)
• Три леммы о точной сетке double: потолок пришпилен сверху, дно ему симметрично (24bc46a)
• Две леммы о носителе обещания: код без пробела, слово и код пустеют вместе (78fa12e)
• Обстановка шага перестала пересобираться на каждом звене: та же запись едет дальше как есть (5f93120)
• Лемма о трёхзначной логике парсера: найденная скобка — решённый исход (103cf5a)
• Две леммы о печати JSON: оператор сравнения всегда в кавычках (be5be26)
• Замер досягаемости: сколько функций корпуса стало высказываемо (6ca55a6)
• Две леммы стали высказываемыми, две теоремы — доказанными (25b1ec2)
• Спецификации назвали связку перенесённой: вместо «ещё 1281 строка JavaScript» стоит таблица двух близнецов с числами (da22f39)
• Вторая половина связки на flang: ядро само сворачивает терм, и на 199 программах вердикт совпал с эталоном знак в знак (0ea3df8)
• Предусловие доехало до ядра: вызывающий снимает, тело допускает, граница проверяет (baddb7a)
• Скрипты замера стали переносимыми, и границу печати пришлось назвать честнее (52533d5)
• Свод корпуса пересчитан один раз в конце сборки: 5761 функция, 4403 тотальных, 663 места частичных форм (134c7e8)
• Проверка типов вписана в цену заведения процесса, и стенд доехал целиком (aeb3917)
• Слово «требует» заведено: лексер, разборщик, типизатор (0f17050)
• Замер планировщика: десятки тысяч работающих процессов, не миллионы — и три причины, все три в реализации (db62198)
• Первая половина связки уехала на flang: обязательства строит близнец, и на 193 программах он не разошёлся с эталоном ни на знак (a3b7b07)
• Пустой квадрат больше не считается проверенным: отчёт называет посчитанное, а не осмотренное (c1521b6)
• Цена перевода в «Долгах» пересчитана после дописанного утверждения: 1926 строк, ×1.72 (c762c1c)
• Числа прозы догнали дерево: двадцать расхождений сторожа чисел закрыты правкой прозы, а не сторожа (ca459a1)
• Точка раскрутки догнала близнеца, а сверка ведомости — пятый источник законов (3277c4b)
• Охват ядра догнал дерево: две новые функции не просто вписаны в список, а получили утверждения (007e170)
• Захват имени в «отобразить» закрыт: подстановка узнала четвёртый связыватель (7935192)
• Естественное преобразование: квадрат коммутирует, и это первый закон, который краснеет на честной программе (d9d54b7)
• Дыра, позволявшая ядру доказать ложь, закрыта одним словом: поле записи перестало отмывать значение (2cbcba8)
• Стенд дорос до пяти видов: цепь и «пинг с конца» ловят то, что остальные прячут (6e7b404)
• Принцип целиком сошёлся с эталоном: близнец назвал лишние случаи и прочтение (f1cd98f)
• Близнец научился считать свободные имена заключения: посылка везёт free и facts (afaeeeb)
• Запрет на «к числу или беда» в stdlib сняли рано: парсер форму знает, а типы и печать в C на flang — нет, и это показала побайтовая сверка (c8dd762)
• Ядро дотянулось до новой функции оболочки — утверждение написано, а охват пересчитан (6ed8c0a)
• Цена пересчитана парным прогоном на законченном вычислителе: +27 % по часам, +56 % по процессору (22fd258)
• Три красных слияния индукции закрыты: близнец узнал носителя и метку, а сверки — новый текст отказа (83ec42b)
• Долг переноса теорем назван точнее: файлов пять, а у пятого запрет ДРУГОЙ (c5e4006)
• Спецификация слоя догнала измерение: девять посылок вместо двух, шесть функций из шести (08f3b8b)
• Спецификация ядра догнала оба правила, и заказ на свёртку вычеркнут наполовину (21f3b49)
• Посылка шага читает свой «если», и «Факториал» корпуса доказан индукцией (96f7ba9)
• Долги самоприменения знают про оболочку, а цена языкового сервера замерена, а не угадана (07fad83)
• Разбор строки в число дошёл до библиотеки: было «ровно одна цифра», стало любая строка — и минус ноль поймали границей, а не глазом (2b45709)
• У умножения появился второй случай: ограничен один сомножитель, второму хватает дна (562664a)
• Оболочка на flang отвечает эталону знак в знак: 91 ввод сверен побайтово, изъятие красит все шесть порч (0ee758b)
• На копейках моноид ЕСТЬ, на «число» его НЕТ — и язык различает это отказом сборки (610cf67)
• Ассоциативность композиции проверена на сетке, и сила проверки названа без прикрас (c6433ca)
• Стенд для замера планировщика: генератор программ с N процессами, печать в C, снятие памяти и времени (9de7638)
• Работа возвращена на место: улика ДО снята на голом дереве, 30 красных, и все тридцать старые (78c9bdc)
• Границы остаток от сняты прогоном: посылок у правила дна ДВЕ, а у потолка ТРИ — и ни одна не окупается (d831b9c)
• Дробное дно больше не доказывает ложь: «если н меньше 2.5» ядро отвергает, а не принимает (efc61c6)
• Найдена своя же дыра: импорт инструмента ЗАПУСКАЛ обход корпуса — семь секунд и чужой вывод в каждом прогоне теста (ed7cb57)
• Граница печати названа, но не измерена: поиск пишет русскими словами, и в английском файле скелет разъедется с утверждением (1781128)
• Незаконченное сохранено на обрыве лимита: работа прервана посреди шага, проверок не было (6c522e7)
• Незаконченное сохранено на обрыве лимита: работа прервана посреди шага, проверок не было (a643243)
• Незаконченное сохранено на обрыве лимита: работа прервана посреди шага, проверок не было (749ed4c)
• Незаконченное сохранено на обрыве лимита: работа прервана посреди шага, проверок не было (7dd28a9)
• Незаконченное сохранено на обрыве лимита: работа прервана посреди шага, проверок не было (1a3ee75)
• План ядра считает и вторую сторону: усиление правила сразу превращается в найденные цепочки (51967b4)
• Оболочка flang заговорила на flang: слой связывается, типизируется и проходит анализ завершаемости (72222e9)
• Имя параметра догнало устройство: ядро спрашивают честной цепочкой, портится она позже (94e8450)
• Число сломанных программ в прозе сверено с деревом: 68, а не 67 (7b6b26c)
• Отказ называет предел, действовавший в этом прогоне, а не записанный в модуле (c663b72)
• Проза догнала язык: точное десятичное в SPEC, третий факт подписи в SPEC доказательства (6e64c89)
• Список строк стал значением библиотеки: 33 функции корпуса писали руками то, чего в двенадцати модулях не было ни одной (a3d7c66)
• Ядро узнало два новых факта: длина не меньше нуля и свёртка держит знак — охват 17 → 43 (b822361)
• Спецификация назвала оба числа и обе границы: нового 0 из 20, перевывода 11 из 11, пределы 256 и 8 (51f6464)
• Деньги считаются точно и доказуемо: программа корпуса, 24 примера, два доказанных утверждения (225539a)
• Близнец компилятора узнал форму «к числу или беда»: обе головы её не знали вовсе (fdb590f)
• Проза догнала дерево: восемь чисел строк, два «Состояния» и раздел про непустоту (e9568db)
• Остаток пути назван числом: между поверхностью и ядром на flang стоят ещё 1281 строка JavaScript (8024bf0)
• Инструмент поиска считает по корпусу два числа: нового 0, перевывода 11 из 11 (9d3fd77)
• Число функций, несущих состояние, названо замером: двадцать девять, а не пятнадцать по памяти (56f30a9)
• Категория объявляет своё равенство: эквивалентность и согласованность с композицией проверены на сетке (65a6d0e)
• Цена замкнутого круга померена парным прогоном: +22 % по часам, +31 % по процессору (f6c48e9)
• Охват ядра вырос на три функции, и все три получили утверждения там же, где стоят: 31 высказано, 29 доказано (9ad4d48)
• Близнец ядра на flang называет покрытие тем, чем оно стало: сказано ли о каждой посылке (4ff886a)
• Оракул поиска доказательства отделён от ядра: предлагает цепочку словами языка, принимает по-прежнему ядро (4bd66c4)
• Ядро читает из подписи третий факт — целость, и на нём стоит правило остатка (580e12f)
• Спецификация слоя названа двумя принципами: долг базы вычеркнут, отрезок описан, ловушка 2⁵³ стоит таблицей (2bb6fa8)
• Точный десятичный тип есть: сотые и тысячные — уточнение числа, а не новый вид значения (233f46c)
• Число сверенного названо точно: 15 828 утверждений вместо 15 812 — круг на flang добавил свои шестнадцать (83c3832)
• Спецификация самоприменения записала замкнутый круг числами: 4014 ответов из 4480 считает сам flang (aba91a2)
• Таблица переписываемых слоёв назвала обе половины ядра доказательства, и сторож чисел их теперь стережёт (f4f1a48)
• Четыре слоя перестали утверждать, что вычислителя на flang нет: он есть, и таблица остаётся по другой причине (2434a20)
• Сверка нашла дыру, которой не было в задании: близнец начальной алгебры не отдавал ядру объявленных типов — четыре суммы из шести расходились (485de0c)
• Сторож объявленной меры стоит и в вычислителе на flang: 44 стережённые программы корпуса (484441d)
• Спецификация слоя доказательства догнала свод: 32 утверждения, и названо, чем упёрлась индукция (69a8bc2)
• Свод и проза догнали дерево: 4025 функций, близнец ядра вырос с 77 до 141, сторожей по-прежнему сто (3899207)
• Строка заказа «Глубина» вычеркнута тестом, а не человеком: перенос стал дословным на обеих функциях корпуса (c0ab2f2)
• Близнец проверки типов научился доказывать непустоту: 240 мест из 240 совпали с эталоном (1a0a3e7)
• Отрицание в logic.flang доказано импликацией в ложь, а де Морган рядом — назван как то, чего ядро не берёт (4356f84)
• Первое доказательство индукцией по числу лежит в дереве, и свод считает носители порознь (fd8cf94)
• Срез вычислителя на flang закрыт целиком: сверено 2318 примеров из 2318, вне среза 0 (cec6b35)
• Согласие специальной функции с общей в higher-order.flang стало доказанным, а не проверенным на примерах (96402ed)
• Ядро на flang догнало эталон целиком: третье правило и развёртка определений донесены, зазор с 450 и 27 расхождений упал до нуля (2fbd12a)
• Спецификация ядра догнала правило умножения и назвала дыру в поле записи (71862ef)
• У библиотеки появились первые два утверждения о поведении: «Знак» и «Чётное» из numbers.flang (910ee10)
• Ядро сворачивает принцип по отрезку той же свёрткой, что и принцип по сумме, а ведомость называет носитель (55fed90)
• Посылку, которая сводится без единого допущения, ядро закрывает само — база больше не требует примера, которого у функции нет (d686b60)
• Вычислитель на flang научился функциям первого класса: сверено 2273 примера из 2317 (aec022f)
• Потолок римской цифры сказан на обеих поверхностях: тысяча и не больше (6a84b91)
• У римской цифры появился потолок: значение не больше тысячи, и это доказано вторым правилом (2851c00)
• Разность натуральных не выходит за точный потолок — утверждение стоит у функции, а не в копии (ff4e218)
• Принцип индукции по отрезку «нат» порождается термом — из двух границ типа, а не из аксиомы (121ed64)
• Ядро берёт умножение: два нат дают неотрицательное произведение (7971a66)
• Посылка принципа несёт свободные имена своего заключения — их считает подстановка, а не второй список связывателей (ea95c19)
• Разобрано, что случится с близнецом при слиянии соседних веток Go: рантайм не страшен, граница входа — задевает (a1c457f)
• Раздел SPEC перестал подразумевать число: сторож меры доезжает до одной программы из трёх, и это печатает тест (48cdea0)
• Зазор до трёх веток эталона измерен числом: 0, 0-при-условии и 158 из 5520 (ecf5daa)
• Шапка близнеца назвала тотальность числом: 128 из 203, и причина у остатка одна, а не три (937e8c4)
• Два случая, которых в дереве нет: кольцо отскоков и тело, не трогающее контекст — оба печатаются побайтово (9ac504f)
• Мёртвый посимвольный сниматель шума снят: 74 строки, которые больше никто не звал, и свод пересчитан (0a62159)
• Свод корпуса пересчитан: 2949 функций, и сторожей не прибавилось ни одного (474b2b4)
• Изъятие показало цену обоих новых правил числом: снимите алгебру — доказано падает с 9 до 6, снимите закрытость — ядро печатает «доказано» о лжи (f8dd313)
• Шапка близнеца называет, чего в нём нет: рантайм параметром и непокрытый порченый AST (f7b6928)
• Остаток непустоты назван числами и образцами: 30 мест из 45 упираются в одну развилку — тип в подписи (075d22f)
• Разбор строки и «символы» знают длину: снято ещё 6 мест, и форма «код символа» закрыта целиком — 0 сторожей из 6 (eeb67be)
• Печать в Rust вошла в список переписанных слоёв: девятый слой самоприменения назван числами, а не обещанием (2e1f518)
• Испорченный AST отвергается тем же текстом: двенадцать отказов подготовки из тринадцати (eb8e646)
• Проза догнала ядро: индукции доступны 50 функций stdlib из 185, было 28, и весь прирост списочный (56f70ff)
• Печать в Rust на flang совпала с эталоном побайтово на всём корпусе: 101 из 101, 44 из 44 со сторожем меры, 19 из 19 моделей (84e25df)
• Отказ сверяется наравне с печатью, и самоприменение знает про восьмой слой (19be75e)
• Числа раздела SPEC подогнаны под прогон: 44 программы со сторожем меры, 13 отказов (837ee5e)
• Граница близнеца на порченом AST измерена и держится числом: совпадает 1 случай из 14 (c7a9297)
• Отношение объёма названо числом, а не округлением: 3223 строки против 1619, ×2.0 (c778d97)
• Принцип индукции целиком собирается на flang и совпал с эталоном побайтово (e46d472)
• Отношение объёма названо числом, а не на глаз: ×1.13, а не «вдвое короче» (282d502)
• У встроенного списка есть начальная алгебра: доказано ядром было 6, стало 9, и три новых — первые утверждения о списке (891da06)
• Проза догнала свод: «случая (а) в корпусе НОЛЬ» перестало быть правдой, и обе половины этого утверждения названы новыми числами (8a2bf5f)
• Свод пересчитан под новый слой: 3111 функций, 2415 тотальных, сторожей по-прежнему 100 (eb962f8)
• Слоёв самоприменения стало девять: SPEC догнал печать в Go (79759a6)
• Печать в Rust на flang сошлась с эталоном побайтово на 99 программах из 101 и на всех 19 моделях FTS (4fb3eb0)
• Порождение принципа индукции переехало на flang: 410 входов сверены побайтово (ba9f456)
• Близнец печати в C читает отметку доказанной непустоты: на помеченной программе 65 вызовов без сторожа совпали с эталоном побайтово (2517e87)
• Девятый слой записан в flang/self/SPEC.md: 323 функции, 228 тотальных, побайтово на 100 программах (e71895e)
• Девятый слой самоприменения записан в flang/self/SPEC.md вместе со своим долгом: границы входа у близнеца C# нет (2800742)
• Печать в Java на самом flang совпала с эталоном побайтово: 101 программа из 101 (aa8be99)
• Печать в Elixir на самом flang совпала с эталоном побайтово на 101 программе из 101 (2bd7fc5)
• Печать в Python на самом flang совпала с эталоном побайтово: 100 программ из 100, 400 файлов из 400 (2bbb94c)
• Третий источник фактов унесён на flang: вердикты сошлись на 8700 утверждениях (e338960)
• Печать в C# на самом flang совпала с эталоном побайтово на всех 100 программах репозитория, включая собственный исходник (3082e05)
• Вердикты близнеца и эталона сошлись на 7902 утверждениях, подделки отвергнуты обе (86127fa)
• Печать flang → Go на самом flang: 100 программ из 101 и 19 моделей совпали побайтово (7a7f271)
• Печать в Rust на flang начата с измеряющего теста: сверка меряет, а не только падает (a804ce5)
• Таблица цены шага пересчитана по помеченному корпусу: разрыв C и Go — 639 раз (0d56375)
• Дифференциальный тест печати в Elixir заведён и мерит; близнец на flang начат (d8463f9)
• Близнец печати в C# начат: основания, разбор программы, граф вызовов и печать выражений — 2769 строк (00bd7e7)
• Близнец печати в Python разбирается: 282 функции, все слои кроме файлов и точки входа (ddb7479)
• Слой сведения ядра переехал на flang: 69 функций, 39 тотальных, сверки пока нет (0af4c51)
• Близнец печати в Java начат: 3037 строк, шесть слоёв из семи (сверки ещё нет) (52e8859)
• Доказанная непустота снимает сторожа у всех восьми целей, а не у одной: правило выбора помощника одно на всех (57fa225)
• Заказ от библиотеки лежит в SPEC ядра таблицей: шесть пунктов, у каждого улика настоящей функцией и код отказа (18f78e9)
• Индукции доступны 28 функций stdlib из 185, и это измерено: второй модуль сказал о себе, доказано по-прежнему ноль (6d02caa)
• lists.flang доведён до числа: 14 функций из 28 говорят о себе, утверждений 15, доказано ядром по-прежнему ноль (89e11c3)
• Библиотека впервые говорит о себе: восемь утверждений о lists.flang, все восемь сеткой, и причина названа кодом отказа (d6ece88)
• Один пример больше не доказывает утверждения обо всех входах: ядро отвергло ложное «в соединении ровно три» (31226ff)
• Непустота стала уточнением типа: 77 мест частичных форм из 280 перестали проверяться во время работы (acf4e5a)
• Близнецы законов догнали эталон: три красных противоречия сборки закрыты (b7973f2)
• Восемь целей считают шаги одинаково: C больше не берёт лишний шаг на входе в цикл (330060b)
• «Не проверяет ничего» спрошено до конца: своё тело чисто у 2013 функций, а вместе с вызванными — у 1737 (a1da777)
• Свод считает обе проверки рантайма: мест не 100, а 380, и без единой проверки не 2096 функций, а 2013 (9b76283)
• Свод второй волны пересчитан ОДИН раз: 3809 функций, 3036 тотальных, 26 утверждений (cc8e8e8)
• Постоянная шага Elixir измерена: словарь процесса стоит 50 нс из 1700, обвинение с него снято (a43fe18)
• Дождались: на 022 напечатанный JS не зависает, а стоит 21 минуту 30 секунд — и отказ у него знак в знак эталонный (a5180c9)
• Контракт называет измеренное: сторож меры сверен с эталоном у ВОСЬМИ целей из восьми, а причина застревания на 022 измерена числом (029d42d)
• Контракт записал: сторожей меры два, проверен был тот, у которого два места из ста, и назвал 278 мест, которых свод не считает (700fc64)
• Журнал вычислителя не приписывает сверке того, чего она не находила (2293917)
• Подготовка программы отказывает теми же словами, что эталон: пять проверок, которых не было (0d9312c)
• Контракт записал: сторож меры сверен с эталоном у семи целей из восьми, и назвал программу, на которой четыре сверки не досчитываются (120a25a)
• Прогонщик Elixir читает и пишет байты: кривая локаль хозяина больше не корёжит кириллицу (e92a38e)
• Шапка вычислителя называет счёт функций числом, а не «шестьюдесятью с лишним» (422a43c)
• Журнал долгов вычислителя называет и то, чего сверка не нашла (f982e4d)
• Отсутствующий подузел доезжает до ряда отсутствующим: «получено undefined» перестало превращаться в «null» (2f39ba4)
• Вычистил из собственной прозы сторожей то, за что они краснеют у других (d76a3a4)
• Глубина вызовов возвращается на место: два места, где машина расходилась с эталоном, и проба на каждое (01850f4)
• Спецификация самоприменения знает про девятый слой и честно называет, чего в срезе вычислителя нет (a75dd06)
• Вычислитель на flang сверен с эталоном на 2012 примерах корпуса: значения и витки совпали все (9ffcceb)
• Размер компилятора на JavaScript в шапке самоприменения отстал на 61 строку: 24440, а не 24379 (e329fb6)
• Своим счётом измерено, насколько врёт сторож пробелов: одиннадцать слов держатся на литерале (98ce046)
• Самоприменённый парсер читает «план» со словарём ввода-вывода: пробел остался один из 147 (a0db3eb)
• Сторож утверждений поймал мою же прозу: «инфиксного и в языке нет» — неправда, слово «и» лексер знает ключевым (7eef13f)
• Самоприменённый парсер читает «прогон»: разбор конкурентности закрыт, пробелов 2 из 147 (020ef27)
• Проза догнала код: «объявленную меру близнец только разбирает» перестало быть правдой в четырёх местах (87b56ad)
• Красноты сборки закрыты: рантаймы Rust и Elixir снова знают свой список, а сторожа догнали дерево (4e3af02)
• Самоприменённый парсер читает «надзор»: пробелов 4 из 147, а не 7 (a590c58)
• Третий поиск описания на каждое ребро был квадратом поверх квадрата: один поиск вместо трёх, анализ types.flang снова влезает в лимит (0f38346)
• Точка раскрутки догнала близнеца: правка «Собрать новое поле» доехала до bootstrap/ (f8e2e26)
• Самоприменённый парсер читает «процесс» вместе со словарём действий: пробелов 7 из 147 (34c865e)
• Самоприменённый парсер читает моноид и монаду: пробелов 11 из 147, а не 18 (40b68a3)
• Слово по номеру в парсере ядра берётся формой: девятнадцать мест перестали стоить длину строки (78fc9eb)
• Самоприменённый парсер читает «к числу или беда» и сам приписывает тип исхода (4090e22)
• Заказ на ядро в записках стал пятью строками из шести, и число названо на месте (b9155a6)
• Размер компилятора на JavaScript в flang/self/SPEC.md догнал дерево: 24645 строк вместо 24379 (5574363)
• Долги, свод и точка раскрутки догнали третьего носителя: 2938 функций корпуса, 2302 тотальных, 636 обычных (a208381)
• Записки догнали четвёртую переписку: «вызов не разворачивается никогда» было решением, а довод при нём был шире решения (d0f4a81)
• Обещания о печати и о стоимости форм сверяются с прогоном: Go брал хвост срезом, а таблица говорила «копия» (f3d38ea)
• Свод собранного дерева пересчитан ОДИН раз: 3329 функций, 2678 тотальных, 25 утверждений (2897521)
• Восьмым видом отказа FLANG_LAW_LIMIT не становится, и в контракте сказано почему (d7a44c6)
• Строка заказа вычеркнута: «глубина дерева неотрицательна» доказана индукцией через развёртку «Глубже» (d74c28b)
• Код, названный прозой, обязан существовать или стоять в списке необещанного: сторож на 52 файла .md вместо одного (24abcd3)
• Печать в C перестала стоить квадрат: шесть взятий по индексу внутри свёрток стали постоянными (f2ee965)
• Печать близнеца ставит сторожа объявленной меры: 94 спуска в 41 программе корпуса совпали с эталоном побайтово (aee6e25)
• «Иногда является» доезжает до сверки значения: необязательное поле записи перестало требоваться как обязательное (026f244)
• Вычислитель flang написан на flang: у самоприменения появился девятый слой, первый исполняющий (a3f46b7)
• Улика владельца закрыта: «высота копии равна высоте оригинала» доказана индукцией, а не посчитана на одном значении (8981852)
• FLANG_LAW_LIMIT перестал быть обещанием: не досчитанный закон отличим от нарушенного (b5f9be9)
• Код отказа, названный любой прозой, обязан существовать: двое выдуманных названы (dce59d9)
• Напечатанная программа на JavaScript отвергает значение вне объявленного типа до вычисления: четыре лжи из четырёх, восемь целей из восьми (ad47106)
• Ядро научилось разворачивать определение функции: четвёртая переписка нормализации с четырьмя названными ограничителями (2648f46)
• Контракт конкурентности записал, где замкнутость набора отказов проверена, а где нет (b7c9083)
• Число строк компилятора в self/SPEC.md досчитано до конца работы: 25034 (4a653c4)
• Числа в прозе сверяются с измерителем: сторож нашёл 26 расхождений, все закрыты (a5569d7)
• sha256 формулы посчитан по архиву, который можно собрать заново и получить те же байты (b41ff09)
• Близнец объявленную меру теперь ПРОВЕРЯЕТ, а не только разбирает: вердикт сошёлся на всех 106 файлах корпуса (5104eea)
• Нарушение приписывается своему утверждению даже при совпавших именах (e7227a0)
• Размер эталона в «Самоприменении» сведён с деревом: 24596 строк, а не 24379 (ba3f026)
• Запрет слова «провер…» перестал смотреть половину ведомости — и слово нашлось (d1ed8d6)
• Точка раскрутки перепечатана скриптом: в неё вошли пять утверждений и проверка постусловия (374d724)
• Долг «у восьми слов нет продукции в самоприменённом парсере» записан закрытым и с ценой (a7c5ddd)
• Близнец-типизатор читает постусловие — дыру показала порча, а не рассуждение (becdd2f)
• Ведомость на flang высказывает утверждение о своём номере формата (44a894c)
• Разборщик на flang высказывает два утверждения о себе: размер пачки и наименьшая основа (761ad24)
• Печать в C на flang высказывает утверждение о себе: «байтов у символа неотрицательно» (c615b11)
• Отставание близнеца ведомости названо числом: два слова, и второе ждёт вычислителя (7d658d6)
• Утверждение «сумма пары неотрицательна» стоит у самой «Суммы пары», а не только в перенесённой копии (66d9870)
• Счёт нарушений моноида берётся один раз, а не дважды в одной записи (06bf3d4)
• Долг из SPEC переписан в замер: закрыт первым из двух названных путей, цена в шуме (c382ab1)
• Та же болезнь у законов вылечена: «нарушений не найдено» перестало печататься об оборванном обходе (49e6be7)
• Полиморфный параметр перестал отвергаться чужими словами, и сверка целей получила свой эталон (94fc42f)
• «Нарушений не найдено» стало означать «искали и не нашли»: сетка примеров прогоняется (0c9d22f)
• Утверждение «значение цифры неотрицательно» стоит у самой функции в leetcode 013, а не в перенесённой копии (b524edd)
• Граница входа напечатанной программы записана в спецификацию: у библиотечного входа её нет, у прогонщика она есть (1f1d474)
• Напечатанная программа на Elixir отвергает значение вне объявленного типа до вычисления: четыре лжи из четырёх, семь целей из восьми закрыты (6522098)
• Напечатанная программа на C# отвергает значение вне объявленного типа до вычисления: четыре лжи из четырёх (9acf560)
• Напечатанная программа на Java отвергает значение вне объявленного типа до вычисления: четыре лжи из четырёх (4546d33)
• Напечатанная программа на Python отвергает значение вне объявленного типа до вычисления: четыре лжи из четырёх (3ad7fff)
• Напечатанная программа на Go отвергает значение вне объявленного типа до вычисления: четыре лжи из четырёх (e32e7be)
• Напечатанная программа на Rust отвергает значение вне объявленного типа до вычисления: четыре лжи из четырёх (8e670b4)
• Напечатанная программа на C отвергает значение вне объявленного типа до вычисления: четыре лжи из четырёх (ae4f41f)
• Скобка итога про утверждения без теоремы стала функцией, а не двумя тройными знаками (abd62da)
• Раскладка охвата по каталогам исправлена и стала исполняемой: пять, одна и одна (1117048)
• Число целей в шапке снято: сказано «у целей печати», потому что счёт я не мерил (0557c12)
• Ведомость перестала называть источником факт, которым не пользовалась (4162f2a)
• Контракт теорката больше не приписывает квадрат вычислителю: копируют цели печати (3d2c68e)
• Обход свёртки и «отобразить» снимает границы один раз: цена соседних форм вернулась к прежней (87ec06f)
• Оболочка отвергает ложь про тип до вычисления, и теперь это сторожат: дверь была закрыта, но ничем не удержана (94c7cae)
• Единственное отличие вида от массива названо и закреплено: запись отвергается (d8d1fad)
• Цикл поручений сверяет вход шага с объявленным типом: «мс: вчера» перестало быть ответом плана (4bf1ca8)
• «Добавить» в эталонном вычислителе за постоянное время: 200 000 элементов — 272 мс вместо 229 634 (9824f27)
• Факт-чекинг сверяет факты с объявленным типом до вычисления: «подтверждено» на значении вне типа больше не выдаётся (6c64911)
• Записки догнали третье правило, и одна из них была ЛОЖНА: «аксиомы появятся вместе с нат» (bf45901)
• Потолок объявленного нат стал вторым фактом ядра: утверждение о разности пары доказано без теоремы (ffad566)
• Охват ядра по корпусу стал измерением: 10 функций из 2800, и семь из них писать нельзя (edec2e1)
• Числа в шапке js.mjs — свои, а не соседские: 919 мс эталона и 133 мс на 200 000 (a8abb8a)
• Самоприменённый парсер читает членство в категории: долг соседней ветки закрыт (8e4b264)
• Напечатанный модуль объясняет свой вид сам: довод переехал внутрь $view (169bb09)
• Два утверждения корпуса уехали из «сетки примеров» в «доказано ядром»: 7 → 9 (0319cde)
• Каталог и SPEC пересчитаны после JS: цена «добавить» постоянна у четырёх целей, дыра осталась у четырёх (2777b2c)
• Сличение таблиц нашло два слова, на которых близнец расходился с эталоном (da33be7)
• «Добавить» в напечатанном JavaScript за постоянное время: 90 с без ответа стали 0,8 с (7c513ad)
• Параметр печати ответа больше не затеняет саму функцию ответа (c6b1384)
• Слой доказательства закрыт: индукция разбирается, пробелов 19 из 147 вместо 20 (1bed171)
• Счёт расхождений бэкенда Elixir сошёлся: их пять, а не четыре (7df8a51)
• Шапка бэкенда Elixir договаривает про «хвост» и называет, что ветвление «добавить» тут даром (3d4f46b)
• Документация догнала прогонщика: у JavaScript больше не «один файл», а модуль и прогонщик рядом (10475dc)
• Разворот конца списка идёт через Enum.reverse: сторож «ни от чего не зависит» остаётся строгим (1e02f10)
• Самоприменённый парсер читает шаг доказательства: пробелов 20 из 147, а не 23 (f25ad02)
• Самоприменённый парсер строит теорему новой формы: пробелов 23 из 147, а не 25 (d94dbbb)
• У JavaScript появился прогонщик: было 1 378 кадров и не тот отказ, стало 10 001 и текст эталона (0508384)
• «Добавить» в напечатанном Elixir за постоянное время: 90 с стали 8,3 с (0dc9814)
• «Добавить» в напечатанном Python за постоянное время: тест цели снова досчитывается (c1468cb)
• Самоприменённый парсер читает постусловие функции: пробелов 25 из 147, а не 27 (be2aab5)
• «Добавить» в напечатанном C# за постоянное время: 273 с стали 2,1 с (ccc2bd4)
• Контракт теорката признал категорию сущностью, а обещание о полноте — бывшим пустым (0bdb79c)
• «Добавить» в напечатанной Java за постоянное время: 63,7 с стали 0,8 с (037aaa0)
• Новый ключ встал в справке после ведомости: сосед покраснел правильным красным, и правился код, а не тест (d08e4c2)
• Цена новой ошибки сборки названа числами: 3 отказа и 4 решения надзора против 1 и 0 (20d5105)
• Печать отбрасывает недостижимое: у import-check из 29 функций едут 2, C похудел с 74 394 байт до 6 284 (871d185)
• Корпус сверки вырос вслед за продукциями, и слой поверхностей назван долгом (e5adf77)
• Слой доказательства записал третий источник фактов и долг, который он сделал нагруженным (f8f4d2a)
• «Добавить» в напечатанном Go за постоянное время: тест цели снова завершается (1388cfa)
• Самоприменённый парсер читает «бифунктор»: пробелов 27 из 147, теоркат закрыт (950c26d)
• Самоприменённый парсер читает «изоморфизм» с обеими стрелками: пробелов 30 из 147 (fa9117e)
• Взятие по номеру в примере меры и в самоприменённом компиляторе стало постоянным (4218514)
• Стрелка-морфизм и её композиция разбираются самоприменённым: пробелов 33 из 147 (99286ad)
• Самоприменённый парсер разворачивает «цепочку» в композиции: пробелов 35 из 147 (9be1f09)
• Расхождение с самоприменением названо в SPEC, а не оставлено молчать (f61f36a)
• Ловушки достижимости названы и закрыты: функция-значение, обработчик процесса, мера, текст сторожа (e5a4d27)
• Самоприменённый парсер читает «единица «Заказ»»: пробелов 38 из 147 (5531f19)
• Самоприменённый парсер читает «вложение» вместе с «даёт»: пробелов 39 из 147 (e11674c)
• Двоичный поиск библиотеки перестал быть линейным: середина берётся встроенной формой (1b25870)
• Объявленные 10 000 кадров у JavaScript стали настоящими: было 1 379 и не тот отказ, стало 10 001 и текст эталона (28d92e9)
• Код отказа печати зовётся FLANG_CONC_UNSUPPORTED: имя одно на все 16 мест, и два сторожа не дают им разойтись (588593a)
• Самоприменённый парсер читает «пересечение»: пробелов разбора 41 из 147, а не 42 (9c951ef)
• Три контракта догнали седьмой вид: видов отказа семь, и самый крупный долг распределённости вычеркнут (fbd5f5b)
• Восемь прогонов на седьмой вид и десятое испытание распределённости: мимо анализа теперь не поднимешься (c4d8e22)
• Достижимость от точки входа считается: 27 из 29 функций import-check не вызываются никогда (ab52036)
• Две аксиомы категории доказываются, и обещание о полноте функтора перестало быть пустым (b71daf0)
• Седьмой вид отказа: FLANG_LINK_DOWN вошёл в анализ, и забытый надзор над представителем стал ошибкой сборки (11410fa)
• «Добавить» в напечатанном Rust за постоянное время: 20 минут стали 1,9 с (6f36d31)
• Категория называет свои стрелки: форма разбирается, а AST сорока моделей не сдвинулся ни на байт (9354587)
• Объявленный тип аргумента стал фактом ядра: одно утверждение уехало из «сетки» в «доказано» (2cbea8c)
• Граница входа сверяет --args с объявленным типом: четыре лжи из четырёх отвергнуты до вычисления (032d6f1)
• Уведомление доехало до всех восьми целей: рантаймов оказалось 28, а не 8 (cc872b6)
• Печатаемые рантаймы C и Rust уезжают к пользователю с уведомлением: восемь файлов из восьми (75a9d59)
• Пять красных закрыты, и все пять — последствия сегодняшней работы, а не старые долги (8203f39)
• Лексер на flang узнал иероглиф 自: работа над «нат» завела 自然数 и сломала сверку (1762682)
• Отношения множеств и монада сверены с эталоном побайтово: два слоя не проверялись ничем (f6cb89f)
• Законы категорий считаются на flang: сетка моноида и изоморфизма перенесена, а её числа сверяются побайтово (945c230)
• sha256 формулы пересчитан по настоящему архиву 0.5.0, точка раскрутки стала видима журналу (cb80317)
• Факт-чекинг сверен с эталоном побайтово: того, ради чего язык создан, на flang не было (55b1c71)
• Версия поднята до 0.5.0 во всех четырёх местах (d24494b)
• Гейт лицензий снова зелёный: печатаемый планировщик JS остался без SPDX (d5be996)
• Журнал изменений перепечатан: он разошёлся с историей ветки ещё до этой работы (eba4594)
• Объявленный предел глубины в C стал пределом: было 1518 кадров и SIGSEGV, стало 10 001 и текст эталона (468d165)
• То же в близнеце: self/types.flang научен неотрицательному без потолка, сторожей ноль (39dc718)
• Неотрицательность переживает выход за точную сетку: терялась вся, остаётся знак (5c7e12a)
• Распределённость: два узла говорят по имени процесса, а разрыв связи испытан разрывом (439f164)
• Числа корпуса догнали хеш-таблицу: 2795 функций, библиотека 12 модулей и 185 функций (316d9a3)
• Словарь перестал зависеть от числа ключей: спуск идёт по цифрам хеша, а не по связям (97f136d)
• Индукция: ядро доказывает утверждения о БЕСКОНЕЧНЫХ типах, и подделку отвергает (aeaf75b)
• Индукция: принцип порождается начальной алгеброй и проверяется как терм (76236bb)
• Постусловие отвечает за своё завершение, а «дано» теоремы — за свой тип: обе улики больше не valid: true (7ff80d8)
• Близнец проверки типов знает точное натуральное: свод корпуса сошёлся, точка раскрутки перепечатана (8b497db)
• Утверждение постусловия типизируется: «результат плюс "строка"» больше не valid: true (5ab2ee3)
• flang test проверяет программу перед прогоном примеров: зелень на программе с ошибкой типов больше не выдаётся (0c6ae17)
• Печать в JavaScript называет уточнённое число числом, а не «неизвестно» (d3f3627)
• Самоприменённый анализ завершаемости знает точный шаг: цепочка без Node называет тот же носитель, что эталон (c76f8a0)
• Ведомость называет пятый носитель обещания: «точным шагом», и он единственный без сторожа (c6925df)
• Точный натуральный тип «нат» снимает сторожа с постоянного шага: 100 мест вместо 115 (06e8dd6)
• Занятость слова в корпусе меряется командой тем же токенизатором, что у языка (fee632e)
• Ведомость доказательства печатается самим flang: 1376 строк против 519 на JavaScript, текст знак в знак и JSON байт в байт (4351f44)
• Оболочка починена: обёртка выражения говорит явно, что сказать нечего (a2ecffa)
• Компилятор flang собирается из клона без Node: «make -C bootstrap», нужны только cc и make (ae973f8)
• Напечатанный JavaScript сам считает глубину и витки: вместо RangeError и зависания — объявленный FLANG_RECURSION_LIMIT (51986c4)
• Из ядра убрано мёртвое: карта вариантов, которую никто не читал, и два перевывоза (67ce68c)
• Указатель библиотеки называет зависимости каждой функции, и только перестал быть догадкой (e59bcdc)
• Семь функций «Списков» приняли список любых значений, и в библиотеке появились промежуток, двоичный поиск, равенство списков, дерево чисел и последний элемент (dab10b8)
• Числа самоприменённого парсера вернулись на место после моей ошибки в слиянии (296c02b)
• Восемь диагностик называют лекарство, а не только болезнь (6b21b3c)
• Названа недостача, которую открыло слово «обеспечивает»: выражение постусловия не проверяет типизатор (0a0711c)
• Доказательство стало объектом: обязательства лежат данными, ядро проверяет терм и само доказано тотальным без сторожа (b554e37)
• Пять дыр статической проверки закрыты: пропущенное «возвращает» больше не выключает типизацию, джокеры плана сверяются с объявлениями, а повтор имени и ложное имя модуля при импорте перестали быть молчаливыми (dca5cb7)
• Решений LeetCode 82: восемь задач из списка невыразимых решены, недостачи языка переписаны с уликами (be14e2c)
• Программа с процессами печатается и в JavaScript: планировщик в модуле, журнал сходится с эталоном побайтово (d2005eb)
• Пробелы разбора у самоприменённого парсера перечислены сторожем: 34 слова лексера без продукции названы поимённо, и список краснеет в обе стороны (3ddbb84)
• Объявленная мера «убывает» разбирается самоприменённым компилятором: AST сошёлся с эталоном побайтово на всём корпусе, неподвижная точка не двинулась (bdd05ef)
• Утверждение о поведении можно высказать: обычная функция пишет постусловие словом «обеспечивает», теорема — доказательство в духе Isar (4ae7b92)
• Напечатанный TypeScript отвечает то же, что ядро: коды и тексты отказов сошлись на 966 входах из 966 (2480cad)
• Двоичный поиск снова двоичный: взятие по номеру встроенной формой, а не обходом (4073199)
• Ключ, поднимающий предел шагов, у команды run перестал быть украшением (f4646ef)
• FLANG_MEASURE вошёл в закрытое множество отказов процесса шестым видом, а сторож множества перестал быть слепым по построению (38e8dd3)
• Шесть целей больше не теряют процессы молча: печать конкурентной программы в цель без планировщика отказывает (26ec179)
• Печать больше не обходит проверку: emit отказывается печатать программу, которую check отвергает (4c6b51a)
• «Проверено на двенадцати значениях» больше не читается как «доказано»: flang check --proof печатает ведомость доказательства (ca16678)
• Сетка из одного семени больше не сходит за сетку: «любое из» на ней отвергается до прогона (fe39642)
• Числа самораскрутки снова можно перепроверить: скрипт, который их печатает, доехал до main (0d56c04)
• Знак нуля переживает компилятор BEAM: −0 в печати Elixir приезжает вызовом, а не литералом (144f03f)

Ещё 374 правки языка снаружи не меняют.

0.4.8 — 9 августа 2026

вложение и пересечение: у множеств появились слова

• Версия 0.4.8: слова множеств — вложение и пересечение — доезжают до пакета (5a7e23a)
• Исчерпание своей кучи стало отказом ПРОЦЕССА, а не смертью программы (2dcae4c)
• Утверждение о недостаче в комментарии стало проверяться прогоном (9bf853c)
• Ящик ограничен объявляемым размером: переполнение стало отказом отправителя (3e6c5e5)
• Множество отказов процесса замкнуто на деле, а барьер замены держит целым пробег, а не сообщение (d06111b)
• Множества получили слова: вложение и общая часть — и по причине, а не по списку (0f529ba)
• Логика пишется инфиксом — «не», «и притом», «или», — а «Ф» от а и б по-прежнему два аргумента (f8588f2)
• Процесс живёт неограниченно: своя куча у процесса, сообщение уезжает в неё копией (5907532)
• Горячая замена живёт под работающим планировщиком, а состояние переезжает проверенной функцией (2c22f26)
• Стек на процесс: наклон устойчив, свободный член гуляет — сказано врозь (6f0ef9c)
• Спуск ограничивает глубину рекурсии, но не цену тела: вторая ложь оценки (da4102c)
• Оценка витков считала длину цикла размером входа — это была ложь в опасную сторону (7cd9c3a)
• Страница Rosetta называла доказанной обычную функцию, а обычной доказанную (623f277)
• Числа В1 и правки контракта: цена вытеснения, ограниченность, счёт строк (5aa4e18)
• Ветка «В» карты отказоустойчивости: вытеснение измерено, ограниченность сделана (5bb25e1)
• Счёт строк компилятора в self/SPEC.md отстал на пять строк (3c8836e)
• Анализ отказов не знал про «код символа», приехавшую соседней веткой (d02816c)
• Иероглиф 码 стоял в таблице слов и отсутствовал в алфавите (dcc5f36)
• Число строк компилятора в self/SPEC.md отстало от дерева (c0883b8)
• Анализ отказов обходил одну и ту же функцию по разу на каждый процесс (285230e)
• Слияние хеш-дерева развело грамматику: поля конструктора остались с запятыми (fa0af93)
• Наблюдение текло в рабочем режиме: журнал доставок писался всегда (9fca07f)
• Контракт называл отказом деление на ноль, которого не бывает (52ed938)
• Процесс мог упасть, а решать о его отказе было некому — и это молчало (a86e396)
• Эмодзи в исходнике .flang разводил два лексера, и это был известный долг (c6253b9)
• Словарь стал логарифмическим: дерево поиска с приоритетом по хешу ключа (683ec9d)
• «Код символа» печатается во все восемь целей и понимается самоприменением (50be733)
• Четыре программы объясняли себя запретом, которого в языке уже нет (1afa107)
• Размер компилятора на JS пересчитан, а сторож числа научился склонять слово (dddfda9)
• Напечатанный разборщик развёл запятую и «и» так же, как эталон (691d08c)
• Запятая принадлежит списку, а не полям конструктора: литерал перестал быть двояким (96bffe6)
• Мера — тоже код, и анализ теперь её обходит (d4966db)
• Прогон объявляет, что проверит по-настоящему, и умеет идти туда, где всё есть (fadc8d9)
• Каталог недостач и SPEC говорят про меру то, что стало правдой (1cbbc8c)
• Евклид и двоичный поиск пишутся на языке, а не обходятся топливом (9af1a70)
• Сторож объявленной меры проверяет убывание, дно и целость (72d1c47)
• Цикл доказывается объявленной мерой, когда двух даровых порядков не хватило (d0f03ad)
• Мера проверяется на число и на то, что в ней одни параметры (9d1fd96)
• У функции есть объявленная мера: «убывает <выражение>» (4f03bce)
• Слово «убывает» стало ключевым: объявить меру было негде (807b993)
• Вечного процесса нет и в рантайме: fl_conc_run сам ограничен пределом пробегов (2c31a2a)
• Заголовок контракта и открытые вопросы узнали про время жизни (4481910)
• Контракт сверен с тем, что измерено: 256 ядер, время жизни и два противоречия (afb22c8)
• Карта до отказоустойчивости: тотальность процессам не мешает, а память — стена (984fc79)
• Кодовая точка символа стала числом: у строк появилось всё, чего им не хватало (3be8782)
• Мерка научилась спрашивать, сколько живёт процесс, а не только как быстро бегает (7cfebc9)
• Синтаксис в SPEC говорил о двух поверхностях, а их четыре (57b29f1)
• Полноширинные ：，（ — те же знаки, что :,( — иначе китайский исходник набирался в двух раскладках (b0ef815)
• Диагностика цитирует слово той поверхности, на которой написан файл, а не русское (7e022c2)
• Поверхностей у языка четыре: эсперанто говорит 127 понятиями из 131, китайский — 129 (684ad72)
• Алфавит лексера на flang дорос до четырёх поверхностей: на «ĉ» он расходился с образцом (f4627ce)
• Напечатанный компилятор не ставил сторож меры и крутился там, где эталон отказывал (37cd2b9)
• Двум функциям библиотеки разрешалось жить без примера по неверной причине (c32b09f)
• Обоснование самоприменения опиралось на число, разошедшееся втрое (e27f963)
• Английский модуль назывался «in English» — на вики это читалось как часть языка (69ad275)
• Каждая задача Rosetta Code говорит на обоих языках, и это сверено деревьями (c03a6a8)
• Выкладка на Rosetta Code делается скриптом, а пароль остаётся у владельца (28473eb)
• Пример полиморфной функции перестал сверяться без подстановки (3044589)
• Стрелка получила закон: обещание, которое проверяется примерами и умеет упасть (9ddacdc)
• Счёт функций в «Долгах» пересчитан по исходникам, а не выбран из двух версий (8cdf5c1)
• Элемент списка берётся по номеру — и доказательство завершения от этого окрепло (f12a0d1)
• Порог «потоки против кооперации» оказался разным вчетверо на двух машинах (99481fe)
• Печать в C молча выбрасывала процессы; теперь у неё свой планировщик (bb68a1a)
• Отметку меры кладёт и копия на flang, и кладёт её в те же места (a76ae85)
• Мера научилась шагу-параметру: «н минус ш» доказывается, когда ш не меняется (777d2a3)
• Инфиксная логика не заводится, и причина названа точнее: арность (7337a10)
• Образцы разбирают строку: посимвольный проход больше не меняет сигнатуру (3a6470b)
• Список из двух конструкторов пишется: разделитель полей смотрит вперёд (584c3da)
• Журнал изменений печатается из тегов и коммитов, а не пишется про них (656e097)

Ещё 42 правки языка снаружи не меняют.

0.4.7 — 7 августа 2026

монада, отказ значением, полиморфизм в репозитории

• Версия 0.4.7: монада, обработка отказа и полиморфизм доезжают до пакета (d9676d2)
• Отказ «к числу» стал значением: столбец из строк складывается, не падая (979d82c)
• Монада получила форму: в монаде разворачивается в разбор до конца разбора (1883935)
• «тотальная» перестала обещать больше, чем доказано: сторож меры (f1c3ead)
• Библиотека схлопнулась по типам; второй параметр нашёл дефект в самоприменении (25b6167)
• Печать в Go давала вариант и функцию одним именем — и молчала об этом (bedf937)
• Шапка HOF.md догнала сделанное: фазы 5 и 6 закрыты, осталось две (efc8238)
• Слияние меры с закрытым полиморфизмом: числа пересчитаны, а не перенесены (6acdf61)
• Число теперь тоже убывает — но только на постоянный шаг и только до проверенного дна (0bee9ac)

Ещё 1 правка языка снаружи не меняют.

0.4.6 — 7 августа 2026

бинарник разговаривает с человеком: check, repl, справка, man

• Версия 0.4.6: то, что ставится из brew, наконец разговаривает с человеком (0633e72)
• Три документа догнали закрытые недостачи, четвёртый нашёл мою ошибку слияния (1b1e3a5)
• Самоприменение понимает полиморфизм и высший порядок; библиотека переехала (c21a8d5)
• Парсер на flang понимает полиморфизм и функции-значения (9afa0e2)
• Бинарник из brew стал инструментом для человека: check, справка, версия, man (febf795)
• Прогон проверял одно чередование из тысячи — теперь сетку семян, и модель измерена (86397d1)
• Теоркат переезжает границу файла целиком: пять видов, а не четыре (c0a2428)
• Материалы к выходу наружу: проверено каждое внешнее обстоятельство, а не вспомнено (9105c86)
• Витрина Rosetta Code выросла вдвое и научилась говорить, чего язык не умеет (ea7c621)
• Три числа файлов в документах считали разное, и нигде не было сказано что (e705bc2)
• Запись о полиморфизме утверждала шире, чем проверяла её улика (6672800)
• Указатель библиотеки печатается из модулей, а не пишется про них (3736eb9)
• Множество, служба REST — и три ловушки языка, найденные при попытке им пользоваться (a56e1da)
• Словарь в языке появился — и вместе с ним недостача, которой никто не знал (9a4700c)
• Логические операции в языке есть — функциями, потому что слово «и» занято (51b76ce)
• Связывание больше не теряет теоркат: доказательство переживало границу файла (5e390a5)
• Поправка к плану: «печатается» не значит «можно писать библиотеку» (b1ecbff)
• Библиотека на функциях-значениях написана — и не там, где должна (d5f830c)
• Функция-значение доехала до восьми целей: понижение легло одним проходом (2614a3b)
• Функция стала значением: дефункционализация оставила граф вызовов конечным (d754261)

Ещё 6 правок языка снаружи не меняют.

0.4.5 — 7 августа 2026

• Версия 0.4.5: оболочка наконец доезжает до brew, плюс ввод-вывод и BEAM (b49f64d)
• Обрезка пробелов стала тотальной: шапка модуля утверждала невозможное (c021778)
• Слои самоприменения перестали ходить по строке позицией — лексер стал тотальным целиком (0b0ca36)
• Процессы flang поехали на настоящей BEAM: печать в Elixir и сверка по набору исходов (2f110f4)
• Язык научился читать файл и ходить в сеть, не перестав быть чистым (5bfdce0)
• Теоркат: изоморфизм и бифунктор — и честная строка о том, чего в изоморфизме не проверяется (39f832f)
• Монада была невыразима: типы стали параметрическими, и печать этого не заметила (716d19b)
• Список недостач языка врал наполовину: восемь записей из пятнадцати неправда (e65a533)
• Тринадцать функций stdlib стояли без примеров по причине, которой нет (bb7faf0)
• Надзор перестал быть объявлением: упавший процесс поднимается к тому же началу (746d4f4)
• Теоркат, шаг 3: моноид и группа — граница «доказано / проверено» внутри одной конструкции (1a864e3)
• Оболочка в бинарнике из brew: язык можно потрогать сразу после установки (ced8665)
• Восемь из двадцати модулей библиотеки уезжали в пакет без SPDX: tsc уносил шапку вместе с import type (c94f283)
• Восемь файлов, приехавших за последние сутки, не несли SPDX — гейт их и поймал (497b195)
• SPDX-заголовки во всём, что уезжает в пакет, и лицензионный гейт в CI (0eeaeab)
• Самая дорогая недостача языка закрыта: четыре задачи и stdlib стали тотальными (47e94fa)

Ещё 4 правки языка снаружи не меняют.

0.4.4 — 6 августа 2026

• Версия 0.4.4: языковой сервер, функтор с законами, конкурентность и Trojan Source (8e4afb5)
• Языковой сервер для .flang: та же проверка, что у «flang check», прямо в буфере (8bc0e08)
• Два слова контракта конкурентности уже были именами: «начальное» и «порог» (b247c19)
• Конкурентность: атомарность по процессу, а не глобальная — и печать в BEAM (5b54c99)
• Rosetta Code: семь канонических задач, и граница языка сторожится тестом (1ddb483)
• Trojan Source: имя FTS уезжало сырым в комментарии — и во весь ftsc (e9763e9)
• Раскладка проекта: REST-пример «библиотека» и выведенные из него правила (c234215)
• Trojan Source: java, csharp и elixir печатали двунаправленные управляющие сырыми (fc9ec0f)
• Плагин asdf рядом с формулой Homebrew: две упаковки одного релиза (c62baa0)
• Теоркат, шаг 2: функтор перестал быть словом без гарантии (046a93a)

Ещё 2 правки языка снаружи не меняют.

0.4.3 — 6 августа 2026

подсветка FTS для Vim едет в пакете

• Версия 0.4.3: подсветка FTS для Vim в пакете (43a89f6)
• Подсветка FTS едет в npm-пакет; тема Workbench из репозитория убрана (6ff44b4)
• Пример: правило жи-ши как исполняемая спецификация с морфизмами и теоремой (bbfdc8d)
• Оболочка flang repl: язык можно потрогать, а не только запустить файл (26e1835)
• Встроенная форма «разложить … на символы»: посимвольный проход стал доказуемым (dfe98e0)
• Контракт модели конкурентности: что можно взять у BEAM, а что придётся отдать (1621cd6)
• Подсветка FTS для Vim: 154 слова языка и проверка, что роли различимы (d63bd4e)

Ещё 2 правки языка снаружи не меняют.

0.4.2 — 6 августа 2026

• Поправка: v0.4.1 не сломан, а описание пакета отстало на пять целей (6cba8e0)
• Слияние двух веток: лимит шагов и запас ёмкости сведены, релиз чинится (021cc13)
• Релиз v0.4.1 выпущен: формула знает хеш, а печать в C — четвёртый случай молчания (88aaec0)
• Компилятор ставится без Node: релизный C, формула Homebrew, честный README (37b8ad7)
• Теоркат, шаг 1: стрелка, композиция, цепочка, единица (b50f540)
• Разбор суждений попал в основную проверку, и пакет получил существующий scope (c369294)
• Самоприменение завершено: неподвижная точка сошлась (0cd0e90)
• Контракт теоркат-поверхности: решения приняты, порядок работ назван (8747bd8)
• flang: печать в Java, C# и Elixir — целей стало восемь (6a59a75)
• Самоприменение: flang₁ собран и работает; неподвижная точка упирается в память (f2070a7)
• Корпус сверки перестал зависеть от чужого домашнего каталога (567bf61)

Ещё 1 правка языка снаружи не меняют.

0.4.1 — 5 августа 2026

Команды пакета отвечают после установки

Исправлено: flang, fts и fts-mcp в 0.4.0 после npm i печатали ноль байт и выходили с кодом 0 — страж точки входа сравнивал пути как строки, а npm ставит команды символьными ссылками.

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

• Команды пакета молчали после установки: страж точки входа не разрешал ссылку (5a4dedd)

0.4.0 — 5 августа 2026

Первая публикация @digitable-lol/fts

Пакет несёт FTS и flang одним набором: fts, fts-mcp, ftsc, ftsvm, ftspec и flang. 327 файлов, 1,1 МБ в архиве, 8,3 МБ распакованный.

Проверено до выпуска: 1738 тестов на Node 20, 22 и 24 без падений, сборка, состав пакета без тестовых файлов, запуск flang из распакованного архива.

• Пакет называется @digitable-lol/fts: scope @digitable нам не принадлежит (f28500e)
• Печать в C: двунаправленные символы, лимит шагов и линейное «добавить» (61b37d8)
• Самоприменение: анализ тотальности на flang — пятый слой, все на месте (a257d50)
• Самоприменение: проверка типов, написанная на flang (38d0ca7)
• flang: тот же дефект печати в C — для прямой рекурсии (ff50af5)
• Самоприменение: парсер flang, написанный на flang (51d1ff1)
• Публикация в npm: пакет открыт, flang входит, публикует тег (92db56c)
• Самоприменение: печать в C, написанная на flang — и найденный ею дефект эталона (cc944fe)
• Самоприменение: лексер flang, написанный на flang (92a0337)
• Ядро FTS на flang: скобочная запись — 56 моделей из 56 побайтово (9164aa3)
• flang: Go печатал литерал варианта записью — расхождение с интерпретатором (c952e3d)
• flang: печать в Python — пятый целевой язык (7e31eea)
• flang: печать в Rust — четвёртый целевой язык (fda937d)
• README: репозиторий называется flang — README теперь описывает flang (124c3d1)
• flang: команда emit — печать в целевой язык из CLI (ec89e78)
• flang: бэкенд C печатал некомпилируемый код, когда вариант одноимён функции (b33b801)
• Ядро FTS на flang: все четыре слоя связались в одну программу (2dd75df)
• Ядро FTS на flang: парсер — цепочка замкнулась (a018496)
• flang: печать в Go — третий целевой язык (a0b40c6)
• Ядро FTS на flang: вычислитель утилит (f87e776)
• Ядро FTS на flang: лексер и печать JSON (eee1f66)
• flang: выборочный импорт «только» — чтобы не дублировать чужой код (328580d)
• flang: связывание модулей — «использует» начинает действовать (af52ac4)
• flang: восемь расхождений между слоями, печать в C, stdlib и LeetCode (cd5d3d7)
• Включить тесты flang в npm test (67213ba)
• feat: flang, языковой сервер, карта покрытия, грамматики и веб-компонент (867d86e)
• Лицензия: BSD 2-Clause вместо унаследованной Apache-2.0 (6dceb8d)
• Убрать research/ из публичного репозитория и починить установку из git (2cac0b1)
• ci: проверять кодогенерацию восемью тулчейнами, запретить молчаливый пропуск (23b0ef6)
• feat: перенести инструменты ftsc, ftsvm и ftspec в репозиторий языка (5957c72)
• feat: add natural English FTS surface (7401559)
• feat: add runtime integrations and benchmarks (d8204a1)
• feat: generate utilities and tests from FTS (83798af)
• feat: add syllogistic Russian FTS surface (dc46125)
• feat: add natural Russian syntax and integrations (3e57b58)
• feat: add Russian real-world FTS examples (73e5d41)
• feat: add strict FTS proof certificates (18b4a3b)
• feat: extract FTS language toolkit (acbf340)

Ещё 8 правок языка снаружи не меняют.