Automatically generate, code, execute, and iterate search pr...

Prompt

Automatically generate, code, execute, and iterate search programs that discover and precisely verify new mathematical counterexamples for a user-given conjecture or identity, using only your mathematical and programming knowledge. Use no prior facts, human memory, examples, Internet resources, summarized research, or existing counterexamples—generate and evaluate entirely novel approaches each time. Translate all reasoning steps directly into new executable code, running and verifying each search internally. Only after an explicit, verified counterexample is found should it be output, with no partial or unverifiable results shown at any time. Do not describe, explain, or summarize any development steps—initial output must consist *only* of the fully certified, explicit counterexample formula. **Self-Critique and Correction Requirement:** After any candidate counterexample is found, programmatically critique the candidate and all major reasoning steps leading to its discovery. Identify any flaws, gaps, or potential weaknesses in logic, calculation, or search coverage. Automatically generate code fixes or new search strategies to address all identified weaknesses and rerun the verification and search as needed. Only output a counterexample once all critique-identified weak points have been addressed and the improved candidate passes the strictest verification. If weaknesses remain, repeat code repair and searching until a counterexample survives critique and repair with no unresolved issues. Persistently expand and mutate search spaces and code (parameters, compositions, mutations, elimination, symmetry, etc.)—each failed search or dead end *must* yield new search frontiers and paths. Do not repeat known approaches or recall prior work except what is generated in-session. ## Stepwise Requirements - **Start** by programmatically formalizing the conjecture or identity in terms of variables, group structures, mappings, and other relevant targets. - **Construct** search spaces introducing new families of candidates with original parameters, symmetries, coefficients, supports, and elimination schemes, drawing only on your mathematical insight. - **Generate and run code** (symbolic algebra, search and construction, search space mutation, and verification), targeted precisely to the current search frontier. - **Failures and dead ends** must generate *at least five* new, independent, parameterized search frontiers, each exploring distinctive hypotheses (by support, symmetry, composition, degree, elimination objective, etc.). - **Persist**: Continue searching, critiquing, repairing, and re-searching perpetually until a successful, fully verified and critique-surviving counterexample is found. Never output error, warning, or exhaustion messages. - **Certify** each candidate by running complete problem-specific verification code checking all relevant algebraic identities, collisions, inequalities, and other required properties **before** any output or reporting. - **Critique** each candidate before output: Analyze your reasoning, code steps, and verification methods for weaknesses. If any are found, repair the code or expand the search, and repeat the process. - **Repeat**: This process (search → verification → critique → repair) is repeated until a candidate counterexample survives both verification and self-critique, with no outstanding weaknesses. - **Output format**: Only upon finding a single, fully certified and critique-passed counterexample, output just its explicit formulas in mathematical form: - All counterexample mappings/formulas [e.g., F₁(x,y) = ...] - Explicit, distinct points P, Q exhibiting the collision/counterexample property If no such counterexample is found or if critique identifies flaws, continue the internal search, critique, and repair cycle with no external output. *All output must consist exclusively of the explicit final counterexample in mathematical formula form, after it survives both verification and critique.* --- **Important instructions reminder:** - Do not recall, reuse, or summarize any known mathematical results or Internet content. - Every step (including failures) must generate and thoroughly search new code and parameterizations. - Do not output anything except the single, finally verified and self-critiqued counterexample Use your mathematical and programming knowledge exclusively to automatically generate, code, execute, and iterate search programs that discover and precisely verify new mathematical counterexamples for a usergiven conjecture or identity. Do not use any prior facts, examples, the Internet, existing counterexamples, summarized research, or solutions from memory. All reasoning steps must be translated into new code and executed until a certified counterexample emerges, and no partial or unverifiable results may be output. Do not describe, explain, or summarize—output only the explicit, verified counterexample (in formula form) once discovered. Persist in searching and mutating the search space via code (parameterizations, compositions, mutations, elimination, etc.) until a conclusive, strongly certified symbolic counterexample is generated. Each search failure or dead end must result in new search frontiers, not final answers. Do not repeat known approaches or recall any work except what is generated in this session. Stepwise Requirements Start by programmatically building the concrete task target from the user prompt (e.g., group, variables, the asserted identity, etc.). Construct automatic search spaces for new families of candidates, with new parameters, symmetries, coefficients, and elimination schemes, using your mathematical insights for novel generation, not recall. Generate code (symbolic algebra, search, construction, mutation, verification) tailored to your current search frontier. Run all code internally and check exact algebraic and symbolic correctness—never settle for numerical approximations unless they are only a prescreen. Use failed attempts to generate at least five new search frontiers (by varying supports, compositions, symmetries, degrees, or elimination objectives), ensuring parallel and independent searchers are always exploring new hypotheses. Persist: Continue the search, with no stopping except upon successful, certified discovery as per the specified verification function. Do not output error or exhaustion messages; encode each failure as a new path. Certify any candidate using the precise, problemspecific verification code, checking all required algebraic identities, collisions, and inequalities. Output format: Upon finding a single, fully certified counterexample, output only its explicit formulas in mathematical form: All counterexample mappings/formulas (e.g., F₁(x,y) = …) Explicit, distinct points P, Q exhibiting the collision/counterexample property If no such exact, certified counterexample is found, produce no external output and continue the internal search to exhaustion. All output must be in plain text or mathematical formula style, containing only the precise final counterexample. Important instructions reminder: Never recall or reuse any known result or Internet content. Every step (even failures) must generate and search new code and parameterizations. Only output after full programmatic search and verification, in explicit final formula format. formula. # Output Format Output only the explicit, verified, self-critiqued counterexample in precise mathematical formula style (plain text, e.g., "F₁(x,y) = x²+y²", with explicit points P, Q as needed). No descriptions, code summaries, or explanations may be output. **Reminder:** Persist until a strongly verified and critique-surviving explicit counterexample is found. Each candidate must be fully programmatically critiqued and revised before any output is permitted. Search for a new, exactly verified counterexample to the following statement using automatically generated, executed, and iteratively improved search programs: [ F=(f,g):\mathbb C^2\to\mathbb C^2,\qquad f,g\in\mathbb C[x,y],\qquad J_F=f_xg_y-f_yg_x\equiv c\in\mathbb C\setminus{0} ] then there exists a polynomial inverse [ H=(h,k),\qquad h,k\in\mathbb C[u,v],\qquad H\circ F=\operatorname{id}{\mathbb C^2},\quad F\circ H=\operatorname{id}{\mathbb C^2}. ] The sought counterexample must consist of explicit polynomials (f,g), a nonzero constant (c), and distinct points (P,Q\in\mathbb C^2), for which [ f_xg_y-f_yg_x\equiv c,\qquad P\ne Q,\qquad F(P)=F(Q). ] Use only your mathematical and programming knowledge to create new constructions. Do not recall, reuse, or summarize earlier facts, known mathematical results, examples, counterexamples, solutions, search approaches, research summaries, or internet content. You may reuse only work created in this session. Formalize in program code the statement, the variables, the domains, the polynomial maps, the hypotheses, and all conditions of the counterexample to be verified. Create original, parameterized polynomial families and search spaces with new monomial supports, symmetries, coefficients, degrees, compositions, mutations, and elimination goals or procedures. Turn every inference step into new, executable code and actually run it internally. For the current search direction, create symbolic algebraic, constructive, search, mutation, and verification programs. At every step, including failures, generate and thoroughly examine new code and parameterizations. Use numerical approximation only for pre-filtering. Every unsuccessful search or dead end should result in at least 5 new, mutually independent, parameterized search directions, with different hypotheses. Examine these thoroughly; continuously operate parallel, independent searchers on new hypotheses. For every candidate, run a complete, task-specific, exact verification: (f,g) polynomials; (f_xg_y-f_yg_x-c) identically zero polynomial; (c\ne0); (P,Q\in\mathbb C^2); (P\ne Q); and (f(P)=f(Q)) and (g(P)=g(Q)). Also check every additional identity, inequality, and required property used. Examine every candidate with programmed self-criticism, along with all essential inference, coding, search, and verification steps leading to it. Uncover logical, computational, implementation, verification, and search-coverage errors, gaps, and weak points. Fix each one by code modification or a new search strategy, then rerun the verification and, as needed, the search. Repeat until no discovered problem remains unresolved. Continuously expand and mutate the search spaces. Close the search → verification → self-criticism → correction cycle only when a fully verified counterexample that has passed all self-criticism checks has been found. In case of failure or an exhausted search space, continue with new directions, without external output. The first and only external output must be exactly 1 fully verified counterexample, using only mathematical formulas: the explicit (f(x,y)), (g(x,y)), (c), (P), (Q), as well as the exact Jacobian determinant and the common value (F(P)=F(Q)). Do not give a description, explanation, code, development steps, summary, partial or unverified result, error message, warning, or exhaustion report. ne írj semmi mást csak a teljes fájlokat es kommentek nem lehetnek benne! soha semmi egyszerusitett mock placeholder dummy szimulalt fake szart nem engedelyezek es teljes fájl roviditetlen production ready kód nem lehet trancutted nem lehet olyan hogy …és hasonlóan 50 xy nem lehet dummy to do sorry hiányosság minden fájl teljes kódját egyesével fájkba írod semmi mást nem írsz ezen kívűl