Our Work

Capítulo 5 del libro "6ta Semana de la Investigación y la Innovación. Exposostenibilidad construyendo futuro", publicado por el Fondo Editorial CEIPA (ISBN 978-958-8752-61-7). El …

Capítulo 5 del libro "6ta Semana de la Investigación y la Innovación. Exposostenibilidad construyendo futuro", publicado por el Fondo Editorial CEIPA (ISBN 978-958-8752-61-7). El capítulo, titulado "Una ventana de oportunidad para la educación en Colombia. Pensamiento crítico y consideraciones acerca del informe de Fedesarrollo", presenta un análisis crítico sobre el estado de la educación superior en Colombia a partir de las conclusiones del informe de Fedesarrollo, con implicaciones para la política educativa y la formación del pensamiento crítico. Pp. 93-113.

In this paper I will be examining how interest rates can impact economic growth. International economic practices and theoretical concepts in the various countries has been discussed. Elasticities of …

In this paper I will be examining how interest rates can impact economic growth. International economic practices and theoretical concepts in the various countries has been discussed. Elasticities of demand may mitigate the effects of high nominal and real interest rates on economic growth, provided that there are mechanisms like low inflation expectations, foreign investors' love for the economy, technological transfer effect and build-up of domestic saving. By using panel data for different countries all over the World, the effectiveness of the interest rate transmission into economic growth has been examined in this paper.    

Introduction: Idiosyncratic drug-induced liver injury (iDILI) remains unpredictable. As adverse responses arise in a small fraction of patients, drugs often fail in later drug development stages …

Introduction: Idiosyncratic drug-induced liver injury (iDILI) remains unpredictable. As adverse responses arise in a small fraction of patients, drugs often fail in later drug development stages or postapproval, thereby tremendously increasing costs and putting patients at risk, highlighting the need for accurate early identification of iDILI liabilities. Covered areas: Using articles from the last 5 years (PubMed), iDILI risk factors are described, in vitro liver models and mechanism-based readout strategies are evaluated on their potential to enable iDILI liability assessment. Expert opinion: Various in vitro liver models are established for disease modeling and DILI prediction.Drawbacks for each of these seem inevitable, making the evaluation of their application domain and iDILI liability assessment potential crucial. A tiered approach could be considered, whereby compounds are initially screened and flagged using simple fit-for-purpose models for DILI prediction, followed by multicellular liver models that integrate the current knowledge of iDILI onset in combination with mechanistic readouts. Multiplexing models within an integrated mechanism-based testing strategycould improve the safety assessment accuracy. Defined in vitro models should integrate critical hepatocyte intrinsic risk factors as well as adaptive immune system components to refine iDILI liability assessment.

Oncology disorders present significant clinical challenges globally,  necessitating evidence-based review of contemporary diagnostic and therapeutic strategies. 

[Copy of the content of the README in the archive] # Artifact guide: lazy solving of extended regular memberships This image contains the solver source, the four solvers used for comparison, 1,998 b…

[Copy of the content of the README in the archive] # Artifact guide: lazy solving of extended regular memberships This image contains the solver source, the four solvers used for comparison, 1,998 benchmarks, and the measurements behind the paper's tables. The scripts in `/eval` regenerate the tables from those measurements. `/reference` holds the data used for the submitted tables, while `/cross-check` holds a complete rerun on a different machine. The image targets Linux/amd64. It runs without network access. Rebuilding it needs network access to fetch Ubuntu packages. For a quick review, load the image and complete steps 1 and 2 below, which take about ten minutes in total. The text after each command states what to expect. For a full review, also run step 3 and consult the sections on covered claims and on the variation in fresh runs. ## Resources and time The paper's reference measurements were taken on a laptop running Ubuntu 24.04 under WSL2, with an Intel Core i7-13850HX (20 physical cores: 8 performance cores at up to 5.3 GHz and 12 efficient cores at up to 3.8 GHz; 28 logical processors) and about 15 GiB of memory. `/cross-check` was run on a Debian 13 server with two AMD EPYC 7502 processors (64 cores, up to 3.36 GHz). Loading the image needs about 0.8 GB of disk space. | step | expected time | |---|---| | 1. `--reference` | seconds | | 2. `--smoke` (40 instances) | about 10 minutes | | 3. `--full` (1,998 instances) | about 2.5 hours on the reference laptop, about 8 hours on 4 cores and 16 GB | | optional: `--full-60s` (60 s limit) | about 13 hours on the 64-core server | The estimates come from the reference run's per-instance times, across twelve configurations and, for `--full`, the supplementary measurements. The harness chooses a number of concurrent solvers from the cores and memory available to Docker, and prints that choice at the start. Use `--jobs N` and `--ostrich-jobs N` to override it. Docker Desktop on Windows adds about ten per cent to the running time. **ARM hosts, including Apple Silicon: use an x86-64 machine for review.** There is no ARM image. The measurements use particular x86-64 binaries: the distributors' release builds of Z3 and cvc5, and an x86-64 Z3-Noodler build. All are recorded by SHA-256 in `/solvers/SHA256SUMS`. ARM versions would be different binaries, and the paper did not measure them. Docker may appear to run the image under emulation on ARM, but its overhead turns instances near the 10-second wall-clock limit into timeouts, producing counts well below those in the paper. ## Load the supplied image Install [Docker Desktop or Docker Engine](https://docs.docker.com/get-started/get-docker/) for your platform before continuing. Confirm that it is available by running `docker version`. ```sh tar -xzf artifact-6698.tar.gz cd artifact-6698 docker load -i nseq-regex-eval-submission.tar.gz mkdir -p results ``` The supplied image is enough for review. The second archive in that folder, `nseq-regex-eval-build.tar.gz`, is only needed to rebuild the image from source or inspect the source outside Docker; see [Rebuilding from source](#rebuilding-from-source). The image tag is `nseq-regex-eval:submission`. Run it without arguments to list the available modes without starting a job. On Windows, use PowerShell; the commands in this file work there as written. Docker Desktop's WSL 2 backend receives the memory allocated to WSL, half the host memory by default. The reference run used about 15 GiB, so before step 3 raise the limit with `memory=` in `%UserProfile%\.wslconfig` if necessary. Otherwise, the harness will run fewer solvers in parallel. ## 1. Regenerate the submission tables ```sh docker run --rm -v "$PWD/results:/results" nseq-regex-eval:submission --reference ``` This takes seconds. It regenerates every paper table from `/reference`, and the tables for the appendix's 60-second run from `/reference-60s`, then compares them with the submitted files. `comparison.json` and `comparison-60s.json` should each report `passed: true` and four matching tables. ## 2. Check that the solvers execute ```sh docker run --rm -v "$PWD/results:/results" nseq-regex-eval:submission --smoke ``` This runs all twelve configurations on 40 instances and takes about ten minutes. `comparison.json` should report `passed: true`. Expect one Z3-Noodler crash (`crash:signal:11` on `eq-mem/eq-mem-0281.smt2`; see Troubleshooting), and many timeouts because the sample covers the full range of difficulties. Its counts are not the paper's counts. ## 3. Run the full experiment ```sh docker run --rm -v "$PWD/results:/results" nseq-regex-eval:submission --full ``` This runs the paper's experiment and its supplementary measurements; see Resources and time for estimates. Leave the machine otherwise idle. On Linux, add `--user "$(id -u):$(id -g)"` if you want to own the output files. ## Optional: the appendix's 60-second run ```sh docker run --rm -v "$PWD/results:/results" nseq-regex-eval:submission --full-60s ``` This is not needed for review, because step 1 already checks the appendix's tables. It takes about thirteen hours on the 64-core server used for the appendix, longer on a smaller machine, and compares its output with `/reference-60s`. ## Running a solver on your own input ```sh docker run --rm -v "${PWD}:/work" nseq-regex-eval:submission --solve /work/problem.smt2 ``` This runs nseq-PA on `problem.smt2` in the current directory, using the paper's options and 10-second limit. It prints the command before the solver output. For nseq-PA, the command is: ```sh /solvers/z3-nseq -t:10000 smt.string_solver=nseq smt.nseq.monadic_whole=false smt.nseq.parikh=false smt.nseq.eager=false smt.nseq.regex_factorization_threshold=0 smt.nseq.regex_factorization_eager=false smt.nseq.regex_dynamic_decomposition=true smt.nseq.eq_approx=false smt.nseq.landing_probes=2 smt.nseq.landing_probe_max=2 smt.nseq.landing_probe_budget=16 model_validate=true -st /work/problem.smt2 ``` The `nseq` configuration is the same solver without the landing decomposition; it differs only in setting `smt.nseq.regex_dynamic_decomposition=false`. `-st` prints search statistics after the answer, and `model_validate=true` checks every model against the input. Use `--config` for another configuration from the tables, such as `nseq`, `noodler`, `cvc5`, `ostrich`, or `z3_upstream`, and use `--timeout` to set another limit in seconds. You can run a supplied benchmark in the same way, for example `--solve /bench/regexes/man-gen/man-gen-0011.smt2`. Most of these options disable other solver features to isolate the procedure evaluated in the paper. ## Benchmarks and settings | Directory | Family | Instances | |---|---|---:| | `auto-gen` | Generated non-primitive memberships | 520 | | `man-gen` | Hand-written memberships | 129 | | `back-ref` | Regex problems with backreferences | 385 | | `smtlib` | Constraints harvested from SMTLIB problems | 454 | | `eq-mem` | Generated memberships with splitting equations | 510 | No constraint set appears twice. `/bench/regexes/manifest.json` records each instance's difficulty, subgroup, status, and content hash. It is copied beside each fresh run, so per-family and scaling breakdowns remain available even when the instance names change. The main comparison has six configurations: `nseq_pa`, `nseq`, `z3_upstream`, `ostrich`, `cvc5`, and `noodler`. The ablations are `pa_no_eager`, `pa_no_cap`, `pa_no_len`, and `pa_no_probes`. `cvc5_default` and `z3_seq` are also recorded, but do not appear in the printed tables. `run.py` contains the options for every configuration. The solver versions are Z3 5.0.0, cvc5 1.3.4, Ostrich 2.0.1, and Z3-Noodler 1.6.1, whose underlying Z3 reports 4.16.0. The nseq fork reports Z3 5.1.0. `/solvers/SHA256SUMS` pins every binary. Each Ostrich process has a 2,000 MB Java heap; native solvers have an 8 GiB address-space ceiling, which limits rather than reserves memory. Every benchmark runs in its own process. The nseq configurations use the monadic end-game engine, disable the optional equation-intersection test, and fix probe defaults to the paper's values. The reference experiment validates models for nseq and upstream Z3, but not for Noodler, cvc5, or Ostrich; this image keeps that setup. Eight models were rejected under `z3_seq`, none from a configuration printed in the paper. ## Outputs and expected results Each invocation creates a directory under `/results`, unless `--output` names one, and writes its console output to `terminal.log`. Reusing `--output` resumes that run, unless the binaries or settings have changed. Arguments after the mode are passed to the harness: for example, `--solvers nseq_pa,nseq,noodler` runs an exploratory subset, not a complete reproduction. `--quick` sits between `--smoke` and `--full`: it runs every configuration on 40 fixed instances per family in about 45 minutes on four cores. Its counts are not the paper's counts. | Output | Meaning | |---|---| | `<configuration>.csv` | Fresh per-instance result, elapsed time, explored nodes, and peak resident memory in MB (`-1` where the run was killed at the outer deadline) | | `logs/<configuration>/...json` | Command, return code, stdout, and stderr for each measurement | | `protocol.json`, `run_config.txt`, `versions.txt` | Effective settings, input list, and binary hashes/versions | | `manifest.json` | Per-instance metadata for reporting | | `tex/table_main.tex` | Main comparison (Table 2 in the submission) | | `tex/table_ablation.tex` | Four-setting ablation (Table 3) | | `tex/table_scaling.tex` | Scaling table (Table 4), explained in Appendix E.4 | | `tex/facts.tex` | Generated prose figures | | `report.md` | Verdict and subgroup breakdowns | | `comparison.json` | Per-family deltas and per-instance changes from the reference | | `claims/`, `claims.txt` | Full-run supplementary measurements and wrapped/original comparisons | In the reference data, nseq-PA solves 1,612 instances: 1,053 satisfiable and 559 unsatisfiable. Plain nseq solves 1,230. The ablation deltas are -44, -8, -14, and -42. Regenerating from `/reference` must reproduce these values exactly. A fresh run may have slightly different counts because instances close to the limit may finish on one machine and time out on another. The section on fresh runs quantifies this effect. `comparison.json` lists every per-instance change; passing its checks does not require matching the paper's counts exactly. A full run also measures landing activity. It rewrites the generated memberships into equations plus primitive memberships, preserves every rewritten input and solver output, and compares solved sets and verdicts instance by instance with the same timeout, grace period, worker count, and memory ceiling as the main run. ## Which claims of the paper the artifact covers | Claim in the paper | Where to check it | |---|---| | Tables 2, 3 and 4, and the prose figures generated with them (family sizes, contradicted statuses, rejected models, instances only nseq-PA answers) | Step 1 regenerates them exactly from `/reference`; step 3 regenerates them from fresh measurements under `tex/` | | Section 6, Results: totals, refutations and models of nseq-PA and nseq, and the mean rates | Table 2; per family in `report.md` | | Section 6: SMTLIB instances with and without word equations, and who solves them | `report.md`, SMTLIB section, table "without equations / with equations" | | Section 6: how often the landing decomposition fires on the generated instances Z3-Noodler answers and nseq-PA does not, and the median node counts | `/cross-check/claims.txt`, section `firing`, as the paper says; `claims.txt` of a fresh `--full` run recomputes it on your machine | | Section 6, Equations and memberships together: the rewritten Generated family | `/cross-check/claims.txt`, section `wrapped`; a fresh `--full` recomputes it and keeps every rewritten input and solver output under `claims/` | | Section 6, The four implementation settings: solved counts per setting | Table 3; per family in `report.md` | | Section 6, The four implementation settings: explored nodes and time on the instances every nseq variant solves, and the models and refutations gained or lost by the probes | Not printed by any script in the image; these follow from the `result`, `time` and `nodes` columns of `/reference/*.csv` (a node count of `-1` means not reported) | | Section 6: instances answered only by nseq-PA or only by Z3-Noodler among the six main solvers | The overall figure is in `tex/facts.tex`; the per-family split is not printed and follows from `/reference/*.csv`. `report.md` has a pairwise head-to-head table and an "only this solver" column, but that column counts over all twelve configurations | | Appendix E.2: the fork's inherited sequence solver; Appendix E.3: cvc5 with and without its flags | `report.md`, rows "Z3 (fork, seq)" and "cvc5 (default)" | | Appendix E.3: the measurement protocol | `protocol.json`, `run_config.txt` and `versions.txt` of any run; the flags in `/eval/run.py` | | Appendix E.5 and Table 5: the experiment at a 60-second limit | Step 1 regenerates Table 5 exactly from `/reference-60s`, whose README summarises the comparison with 10 s; `--full-60s` reruns it | ## What the artifact cannot reproduce - **The theorems of Section 4.4 and Appendix A.** These are pen-and-paper proofs; the artifact contains no mechanised version. - **Exact times and exact solved counts on other hardware.** Solved counts vary   slightly by machine; the next section quantifies that variation. - **Measurements on ARM.** See the note at the top. - **The cross-check run.** It is quoted from `/cross-check` and was measured on   a server a reviewer will not have. A fresh `--full` produces comparable data   on the reviewer's machine. ## What a fresh run will and will not reproduce Verdicts are stable across machines, but solved counts near the time limit vary slightly. In addition to the paper's run, the full sweep was repeated five times on two machines, using the solver binary, instances, and protocol described above: | run | machine | nseq-PA | nseq | largest change in any count | |---|---|---:|---:|---| | the paper, `/reference` | Intel i7-13850HX laptop, Ubuntu 24.04 under WSL2 | 1612 | 1230 | | | natively again | the same laptop and WSL | 1612 | 1230 | 11 (Z3) | | this image, Docker Desktop | the same laptop | 1600 | 1226 | 50 (Ostrich2) | | `/cross-check` | AMD EPYC 7502 server, Debian 13 | 1599 | 1226 | 17 (Z3) | | natively again | the same server | 1599 | 1226 | 18 (Z3) | | this image, podman | the same server | 1599 | 1226 | 18 (Ostrich2) | In all of these runs, no instance changed from `sat` to `unsat` or vice versa, no answer contradicted a declared status, and `verify.py` passed. Every count difference comes from an instance crossing the 10-second limit. The conclusions used in the paper hold in every run: nseq-PA has the highest mean rate on satisfiable instances, Z3-Noodler has it on unsatisfiable instances, the landing decomposition gains between 373 and 382 instances, and no Table 3 ablation delta changes by more than seven. Per-instance results for the four newer runs are in `/cross-check/reruns`. Three factors affect counts: processor choice, Docker Desktop, and Ostrich2's own run-to-run variation. The processor affects solvers in different directions. On instances both machines solve, the nseq configurations are 1.28 to 1.50 times slower on the server than on the laptop (median time ratios). cvc5, Z3-Noodler, and Ostrich2 are faster there, with ratios of 0.92, 0.88, and 0.78; upstream Z3 is almost unchanged, at 1.02. We have not established the cause. The laptop has the higher clock rate, while the server has more cache and cores; Ostrich2's Java runtime also spreads helper threads over the cores it sees. No hardware counters were collected. In practical terms, the server favours the competitors slightly, whereas the laptop favours nseq-PA. These are median ratios. The slower machine loses instances already close to the limit: the thirteen nseq-PA instances lost on the server took 6.09 to 9.62 seconds in the paper run, and no instance solved faster than that changed. Differences on instances well inside the reference limit are therefore unlikely to be hardware effects. Docker Desktop adds time on Windows. In two back-to-back runs on the paper's laptop, nseq-PA took about 10 per cent longer in Docker Desktop than natively under WSL, and solved 1,608 instances rather than 1,613. On the Linux server, the container made no material difference: native and podman runs solved exactly the same instances for every nseq configuration, with median times within 1.2 per cent. On Windows, expect each nseq row to solve a few fewer instances than the paper reports. Ostrich2 has the largest run-to-run variation. Between the native and podman sweeps on the same idle server, 30 instances were solved in only one run and 14 in only the other. All were within about two and a half seconds of the limit; its count ranged from 686 to 754 across the runs. Treat the Ostrich2 row with the most tolerance. For the same reason the paper's Ostrich2 rows are the better of two runs each, 736 against 715 at 10 seconds and 859 against 841 at 60; the other runs are in `/reference/other-runs` and `/reference-60s/other-runs`. ## Troubleshooting and inspection A run fails if a solver is missing, an option is invalid, an exit is unrecognised, the inventory is incomplete, or a verdict contradicts its declared status. Start with `terminal.log`, then inspect the per-instance log it names. If the host reports memory pressure, reduce the worker counts. The harness records unsolved outcomes separately: timeout, reported `unknown`, unsupported input, out of memory (`memout`), and crash. None is counted as an answer. Some original inputs request a model unconditionally. If this request fails after a valid `unsat` or `unknown` result, the diagnostic remains in the log but the result stands. Any other solver error still fails validation. Two backreference inputs use Z3's prefix-argument spelling of `re.loop`, rather than indexed SMTLIB syntax. Ostrich accepts the indexed form elsewhere, but rejects these two before producing a verdict. They are therefore labelled `unsupported`, with the message and symbol kept in the log. Three cvc5 inputs are likewise kept in their original spelling and labelled `unsupported` where cvc5 rejects the regex syntax. Any other execution that ends without a verdict is an error. A process killed by a signal is labelled `crash:signal:N`, and one stopped on an internal assertion `crash:assertion`, rather than being counted as a timeout. This distinction matters for Z3-Noodler, which segfaults on 78 of the 1,998 inputs: 39 in `auto-gen`, and 39 in the `eq-mem` copies of the same regexes. A bounded repetition of a complemented word is enough to trigger the crash in about a tenth of a second: `((_ re.loop 2 2) (re.comp (str.to_re "ca")))`. Every other solver in the artifact answers this input. The failure occurs before any string solver starts, which is why the same binary also crashes with `smt.string_solver=seq`. The reference CSVs record these 78 rows as `timeout`. A fresh `--full` run will therefore report `crash:signal:11` where `/reference/noodler.csv` says `timeout`. Both outcomes are unsolved, so neither solve counts nor table values change, and `verify.py` reports no difference. For manual inspection, `--shell` opens a shell in the image with the same mount as the steps above: ```sh docker run --rm -it -v "$PWD/results:/results" nseq-regex-eval:submission --shell ``` Third-party notices are in `/notices`. Z3 and cvc5 are their distributors' release binaries; Z3-Noodler is built from its 1.6.1 source release. All are shipped as measured. ## Rebuilding from source `nseq-regex-eval-build.tar.gz` contains the Dockerfile and its complete build context. The solver source is also in the image at `/src/z3-nseq`. To inspect or use the source outside Docker, extract the archive. To rebuild the image, run the following from the root of the extracted archive: ```sh docker build --platform linux/amd64 --provenance=false --build-arg BUILD_JOBS=6 -t nseq-regex-eval:submission -f docker/Dockerfile . ``` The build takes about fifteen minutes and needs network access for Ubuntu packages. It compiles the solver as a CMake Release build and copies the competitors unchanged. Another compiler or system library can shift timings, so compare solved counts and per-instance outcomes rather than seconds. ## Authorship and licence The artifact and the nseq solver are by Clemens Eisenhofer. The Z3 source on which it is built retains its own author headers. The `back-ref` family was collected from an external benchmark set rather than generated here. Benchmarks are numbered within each family, so no input path carries a name. `/LICENSE` covers the harness, scripts, benchmarks, reference measurements, and modifications to the Z3 source. It permits an evaluation committee to run, inspect, and modify them. The competitor solvers retain their own licences, reproduced under `/notices`. ## Requested badges **Available.** The archive is deposited under a DOI, with its SHA256 on the submission form. **Functional.** Step 1 regenerates every table in the evaluation and appendix, along with the prose macros, from stored measurements and compares them with the submitted files. This checks the path from data to tables in seconds. Step 2 shows the solvers running, and step 3 reruns the measurements. Every number in the evaluation has been checked against the shipped data. `/cross-check` records how each number changes in a full rerun on different hardware. **Reusable.** The harness is not tied to this paper. `--solve` runs any configuration on any SMT-LIB file. `run.py` accepts any subset of solvers and configurations over an SMT-LIB benchmark tree arranged in family directories, like `/bench/regexes`. `tables.py`, `scaling_table.py`, and `analysis.py` also run standalone on a results directory. Per-instance logs retain the command, return code, stdout, and stderr for every measurement, so a disputed row can be traced to the actual run. The solver source is included, and the build archive rebuilds the image from it. Unsolved outcomes are recorded by kind rather than collapsed into `timeout`, which is how the Z3-Noodler crash above was identified.

Ushbu tezisda sanoat obyektlarida, xususan nasos stansiyalarida avtomatlashtirish vositalarining texnik holatini monitoring qilish va yuzaga kelishi mumkin bo‘lgan nosozliklarni oldindan bashora…

Ushbu tezisda sanoat obyektlarida, xususan nasos stansiyalarida avtomatlashtirish vositalarining texnik holatini monitoring qilish va yuzaga kelishi mumkin bo‘lgan nosozliklarni oldindan bashoratlash masalasi ko‘rib chiqiladi. Tadqiqotda bosim, sarf, sath va vibratsiya kabi texnologik parametrlarni tahlil qilish orqali uskunaning texnik holatini baholashga e’tibor qaratilgan. Bashoratlash jarayonida Python dasturlash muhiti va mashinali o‘qitishning chiziqli regressiya usulidan foydalanish taklif etiladi. 

Pulmonology disorders present significant clinical challenges globally,   necessitating evidence-based review of contemporary diagnostic and therapeutic strategies. 

Mazkur tezisda boshlang‘ich ta’lim jarayonida STEAM (Science, Technology, Engineering, Art, Mathematics) texnologiyasidan foydalanish asosida o‘quvchilarda kelgusidagi kasbiy faoliya…

Mazkur tezisda boshlang‘ich ta’lim jarayonida STEAM (Science, Technology, Engineering, Art, Mathematics) texnologiyasidan foydalanish asosida o‘quvchilarda kelgusidagi kasbiy faoliyat uchun zarur bo‘lgan dastlabki ko‘nikmalarni rivojlantirish hamda o‘quv topshiriqlarini bajarish natijalari orqali ta’lim samaradorligini baholash masalalari yoritiladi. STEAM yondashuvining fanlararo integratsiya, amaliy faoliyat, muammoli vaziyatlarni hal etish, ijodkorlik, tanqidiy fikrlash va hamkorlikka yo‘naltirilganligi uning didaktik imkoniyatlarini belgilaydi. O‘quv topshirig‘ining mazmuni, amaliy yo‘nalganligi, murakkablik darajasi, o‘quvchining mustaqilligi, ijodiy yondashuvi, fanlararo bog‘liqlik, natijani taqdim etishi va refleksiyasi ta’lim samaradorligini baholashning muhim omillari sifatida asoslanadi.

Keng miqyosda olingan retrospektiv tahlilga ko‘ra, dunyodagi teleko‘rsatuvlarning 60 foizini ko‘ngilochar dasturlar tashkil etadi. Televideniening OAV sifatidagi taqdiri hal qilinayo…

Keng miqyosda olingan retrospektiv tahlilga ko‘ra, dunyodagi teleko‘rsatuvlarning 60 foizini ko‘ngilochar dasturlar tashkil etadi. Televideniening OAV sifatidagi taqdiri hal qilinayotib, ko‘pincha bu dasturlar tanqid ob’ektiga aylanadi.  Mazkur maqolada O‘zbekiston va Yaponiya televideniyalari misolida axboriy va ko‘ngilochar dasturlar rivojlanishining asosiy tendensiyalari, televidenie sanoatining jamoatchilik talablariga qanday javob berishi tahlil qilinadi. Olingan natijalar asosida muallif tomonidan teleindustriyadagi talab va taklif o‘rtasidagi bog‘liqlik tadqiq etilgan.

Discrete-event simulation framework accompanying the manuscript "Hybrid blockchain consensus algorithms trade communication overhead against Byzantine fault tolerance in a quantitative simulation benc…

Discrete-event simulation framework accompanying the manuscript "Hybrid blockchain consensus algorithms trade communication overhead against Byzantine fault tolerance in a quantitative simulation benchmark". The framework implements four hybrid blockchain consensus algorithms, Delegated Proof of Stake Work (DPoSW), Proof of Stake and Work (PoSW), Proof of CASBFT (PoCASBFT) and Delegated Byzantine Proof of Stake (DBPoS), together with three pure-protocol baselines (PurePoW, PurePBFT, PureDPoS) implemented under identical parameters so that each hybrid can be benchmarked directly against the primitive it extends. Seven metrics are modelled: throughput, consensus latency, transaction finality, energy consumption per transaction, fault tolerance under Byzantine nodes, a documented five-criterion security score, and per-round message complexity. All reported latency, energy and message-complexity values are computed as closed-form expected values rather than by Monte Carlo sampling, giving a uniform modelling methodology across all algorithms; an independent Monte Carlo validation script is included for the one algorithm whose model contains a genuine random variable. The simulator and the validation script depend only on the Python standard library, so all numerical results in the manuscript can be reproduced without installing any third-party package. Precomputed results (JSON and CSV) and figures are included so that reported values can be inspected without re-running anything.