Datasets:
Dataset Preview
The full dataset viewer is not available (click to read why). Only showing a preview of the rows.
The dataset generation failed because of a cast error
Error code: DatasetGenerationCastError
Exception: DatasetGenerationCastError
Message: An error occurred while generating the dataset
All the data files must have the same columns, but at some point there are 4 new columns ({'state_before', 'annotation_status', 'metadata', 'state_after'})
This happened while the json dataset builder was generating data using
hf://datasets/uw-math-ai/APRIL/train/mlme_train.jsonl (at revision 5966834e50a00c31d914b34ea6f5b88a44e33076), [/tmp/hf-datasets-cache/medium/datasets/95632298063641-config-parquet-and-info-uw-math-ai-APRIL-24cc2603/hub/datasets--uw-math-ai--APRIL/snapshots/5966834e50a00c31d914b34ea6f5b88a44e33076/train/lme_train.jsonl (origin=hf://datasets/uw-math-ai/APRIL@5966834e50a00c31d914b34ea6f5b88a44e33076/train/lme_train.jsonl), /tmp/hf-datasets-cache/medium/datasets/95632298063641-config-parquet-and-info-uw-math-ai-APRIL-24cc2603/hub/datasets--uw-math-ai--APRIL/snapshots/5966834e50a00c31d914b34ea6f5b88a44e33076/train/mlme_train.jsonl (origin=hf://datasets/uw-math-ai/APRIL@5966834e50a00c31d914b34ea6f5b88a44e33076/train/mlme_train.jsonl), /tmp/hf-datasets-cache/medium/datasets/95632298063641-config-parquet-and-info-uw-math-ai-APRIL-24cc2603/hub/datasets--uw-math-ai--APRIL/snapshots/5966834e50a00c31d914b34ea6f5b88a44e33076/train/thme_train.jsonl (origin=hf://datasets/uw-math-ai/APRIL@5966834e50a00c31d914b34ea6f5b88a44e33076/train/thme_train.jsonl), /tmp/hf-datasets-cache/medium/datasets/95632298063641-config-parquet-and-info-uw-math-ai-APRIL-24cc2603/hub/datasets--uw-math-ai--APRIL/snapshots/5966834e50a00c31d914b34ea6f5b88a44e33076/train/tme_train.jsonl (origin=hf://datasets/uw-math-ai/APRIL@5966834e50a00c31d914b34ea6f5b88a44e33076/train/tme_train.jsonl)]
Please either edit the data files to have matching columns, or separate them into different configurations (see docs at https://hf.co/docs/hub/datasets-manual-configuration#multiple-configurations)
Traceback: Traceback (most recent call last):
File "/usr/local/lib/python3.12/site-packages/datasets/builder.py", line 1887, in _prepare_split_single
writer.write_table(table)
File "/usr/local/lib/python3.12/site-packages/datasets/arrow_writer.py", line 674, in write_table
pa_table = table_cast(pa_table, self._schema)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "/usr/local/lib/python3.12/site-packages/datasets/table.py", line 2272, in table_cast
return cast_table_to_schema(table, schema)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "/usr/local/lib/python3.12/site-packages/datasets/table.py", line 2218, in cast_table_to_schema
raise CastError(
datasets.table.CastError: Couldn't cast
correct_proof: string
incorrect_proof: string
theorem: null
src_hash: string
correct_name: null
incorrect_name: null
correct_formal: null
incorrect_formal: null
correct_informal: null
incorrect_informal: null
path: string
line: int64
col: int64
metadata: null
annotation_status: null
error: string
line_at_error: string
state_at_error: string
state_before: null
state_after: null
explanation: string
fix_suggestion: string
source: string
error_type: string
split: string
to
{'path': Value('string'), 'correct_proof': Value('string'), 'incorrect_proof': Value('string'), 'theorem': Value('null'), 'src_hash': Value('string'), 'correct_name': Value('null'), 'incorrect_name': Value('null'), 'correct_formal': Value('null'), 'incorrect_formal': Value('null'), 'correct_informal': Value('null'), 'incorrect_informal': Value('null'), 'line': Value('int64'), 'col': Value('int64'), 'error': Value('string'), 'line_at_error': Value('string'), 'state_at_error': Value('string'), 'explanation': Value('string'), 'fix_suggestion': Value('string'), 'source': Value('string'), 'error_type': Value('string'), 'split': Value('string')}
because column names don't match
During handling of the above exception, another exception occurred:
Traceback (most recent call last):
File "/src/services/worker/src/worker/job_runners/config/parquet_and_info.py", line 1347, in compute_config_parquet_and_info_response
parquet_operations = convert_to_parquet(builder)
^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "/src/services/worker/src/worker/job_runners/config/parquet_and_info.py", line 980, in convert_to_parquet
builder.download_and_prepare(
File "/usr/local/lib/python3.12/site-packages/datasets/builder.py", line 884, in download_and_prepare
self._download_and_prepare(
File "/usr/local/lib/python3.12/site-packages/datasets/builder.py", line 947, in _download_and_prepare
self._prepare_split(split_generator, **prepare_split_kwargs)
File "/usr/local/lib/python3.12/site-packages/datasets/builder.py", line 1736, in _prepare_split
for job_id, done, content in self._prepare_split_single(
^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "/usr/local/lib/python3.12/site-packages/datasets/builder.py", line 1889, in _prepare_split_single
raise DatasetGenerationCastError.from_cast_error(
datasets.exceptions.DatasetGenerationCastError: An error occurred while generating the dataset
All the data files must have the same columns, but at some point there are 4 new columns ({'state_before', 'annotation_status', 'metadata', 'state_after'})
This happened while the json dataset builder was generating data using
hf://datasets/uw-math-ai/APRIL/train/mlme_train.jsonl (at revision 5966834e50a00c31d914b34ea6f5b88a44e33076), [/tmp/hf-datasets-cache/medium/datasets/95632298063641-config-parquet-and-info-uw-math-ai-APRIL-24cc2603/hub/datasets--uw-math-ai--APRIL/snapshots/5966834e50a00c31d914b34ea6f5b88a44e33076/train/lme_train.jsonl (origin=hf://datasets/uw-math-ai/APRIL@5966834e50a00c31d914b34ea6f5b88a44e33076/train/lme_train.jsonl), /tmp/hf-datasets-cache/medium/datasets/95632298063641-config-parquet-and-info-uw-math-ai-APRIL-24cc2603/hub/datasets--uw-math-ai--APRIL/snapshots/5966834e50a00c31d914b34ea6f5b88a44e33076/train/mlme_train.jsonl (origin=hf://datasets/uw-math-ai/APRIL@5966834e50a00c31d914b34ea6f5b88a44e33076/train/mlme_train.jsonl), /tmp/hf-datasets-cache/medium/datasets/95632298063641-config-parquet-and-info-uw-math-ai-APRIL-24cc2603/hub/datasets--uw-math-ai--APRIL/snapshots/5966834e50a00c31d914b34ea6f5b88a44e33076/train/thme_train.jsonl (origin=hf://datasets/uw-math-ai/APRIL@5966834e50a00c31d914b34ea6f5b88a44e33076/train/thme_train.jsonl), /tmp/hf-datasets-cache/medium/datasets/95632298063641-config-parquet-and-info-uw-math-ai-APRIL-24cc2603/hub/datasets--uw-math-ai--APRIL/snapshots/5966834e50a00c31d914b34ea6f5b88a44e33076/train/tme_train.jsonl (origin=hf://datasets/uw-math-ai/APRIL@5966834e50a00c31d914b34ea6f5b88a44e33076/train/tme_train.jsonl)]
Please either edit the data files to have matching columns, or separate them into different configurations (see docs at https://hf.co/docs/hub/datasets-manual-configuration#multiple-configurations)Need help to make the dataset viewer work? Make sure to review how to configure the dataset viewer, and open a discussion for direct support.
path
string | correct_proof
string | incorrect_proof
string | theorem
null | src_hash
string | correct_name
null | incorrect_name
null | correct_formal
null | incorrect_formal
null | correct_informal
null | incorrect_informal
null | line
int64 | col
int64 | error
string | line_at_error
string | state_at_error
string | explanation
string | fix_suggestion
string | source
string | error_type
string | split
string |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
CategoryTheory.Bicategory.id_whiskerLeft_symm.lean
|
import Mathlib.CategoryTheory.NatIso
import Mathlib.CategoryTheory.Bicategory.Basic
open CategoryTheory
open Bicategory
open Category Iso
variable {B : Type u} [Bicategory.{w, v} B] {a b c d e : B}
theorem theorem_28010 {f g : a ⟶ b} (η : f ⟶ g) : η = (λ_ f).inv ≫ 𝟙 a ◁ η ≫ (λ_ g).hom := by
simp
|
import Mathlib.CategoryTheory.NatIso
import Mathlib.CategoryTheory.Bicategory.Basic
open CategoryTheory
open Bicategory
open Category Iso
variable {B : Type u} [Bicategory.{w, v} B] {a b c d e : B}
theorem theorem_28010 {f g : a ⟶ b} (η : f ⟶ g) : η = (λ_ f).inv ≫ 𝟙 a ◁ η ≫ (λ_ g).hom := by
rw [← Iso.inv_comp_eq, leftUnitor_naturality, Category.assoc]
| null |
25ba40f63317e3a83081a8d23cd8f635e281bac38cb2c2548dc0bcecd9660e64
| null | null | null | null | null | null | 8
| 6
|
tactic 'rewrite' failed, did not find instance of the pattern in the target expression
?f = hom ?α ≫ ?g
B : Type u
inst✝ : Bicategory B
a b : B
f g : a ⟶ b
η : f ⟶ g
⊢ η = (λ_ f).inv ≫ 𝟙 a ◁ η ≫ (λ_ g).hom
|
rw [← Iso.inv_comp_eq, leftUnitor_naturality, Category.assoc]
|
B : Type u inst✝ : Bicategory B a b : B f g : a ⟶ b η : f ⟶ g ⊢ η = (λ_ f).inv ≫ 𝟙 a ◁ η ≫ (λ_ g).hom
|
The proof fails because the rewrite tactic cannot match the pattern `?f = hom ?α ≫ ?g` in the target expression, as the target is not in the expected form for `Iso.inv_comp_eq` to apply directly.
|
Use the `simp` tactic which can automatically handle all necessary rewrites and simplifications for this bicategorical identity.
|
herald
|
lme
|
train
|
OmegaCompletePartialOrder.ωSup_eq_of_isLUB.lean
|
import Mathlib.Control.Monad.Basic
import Mathlib.Dynamics.FixedPoints.Basic
import Mathlib.Order.Chain
import Mathlib.Order.Hom.Order
import Mathlib.Order.Iterate
import Mathlib.Order.Part
import Mathlib.Order.OmegaCompletePartialOrder
open OmegaCompletePartialOrder
variable {α : Type u} {β : Type v} {γ : Type*}
variable [Preorder α] [Preorder β] [Preorder γ]
variable [Preorder α] [Preorder β] [Preorder γ]
variable (c c' : Chain α)
variable (f : α →o β)
variable (g : β →o γ)
variable (f : α →o β)
variable (g : β →o γ)
variable (g : β →o γ)
variable {f}
open OmegaCompletePartialOrder
variable {α : Type u} {β : Type v} {γ : Type*}
variable [OmegaCompletePartialOrder α]
variable [OmegaCompletePartialOrder α]
theorem theorem_2190 {c : Chain α} {a : α} (h : IsLUB (Set.range c) a) : a = ωSup c := by
rw [le_antisymm_iff]
simp only [IsLUB, IsLeast, upperBounds, lowerBounds, Set.mem_range, forall_exists_index,
forall_apply_eq_imp_iff, Set.mem_setOf_eq] at h
constructor
· apply h.2
exact fun a ↦ le_ωSup c a
· rw [ωSup_le_iff]
apply h.1
|
import Mathlib.Control.Monad.Basic
import Mathlib.Dynamics.FixedPoints.Basic
import Mathlib.Order.Chain
import Mathlib.Order.Hom.Order
import Mathlib.Order.Iterate
import Mathlib.Order.Part
import Mathlib.Order.OmegaCompletePartialOrder
open OmegaCompletePartialOrder
variable {α : Type u} {β : Type v} {γ : Type*}
variable [Preorder α] [Preorder β] [Preorder γ]
variable [Preorder α] [Preorder β] [Preorder γ]
variable (c c' : Chain α)
variable (f : α →o β)
variable (g : β →o γ)
variable (f : α →o β)
variable (g : β →o γ)
variable (g : β →o γ)
variable {f}
open OmegaCompletePartialOrder
variable {α : Type u} {β : Type v} {γ : Type*}
variable [OmegaCompletePartialOrder α]
variable [OmegaCompletePartialOrder α]
theorem theorem_2190 {c : Chain α} {a : α} (h : IsLUB (Set.range c) a) : a = ωSup c := by
rw [le_antisymm_iff]
simp only [IsLUB, IsLeast, upperBounds, lowerBounds, Set.mem_range, forall_exists_index,
forall_apply_eq_imp_iff, Set.mem_setOf_eq] at h
constructor
· apply h.2
exact fun x ⟨i, hi⟩ => hi ▸ le_ωSup c i
· rw [ωSup_le_iff]
apply h.1
| null |
9d8a4e4f3d0218d8bfc6e227b67583e15be1160c964829a1254725e9484ed986
| null | null | null | null | null | null | 24
| 4
|
type mismatch
fun x x_1 => ?m.2447
has type
(x : ℕ) → (x_1 : ?m.2448 x) → ?m.2449 x x_1 : Sort (imax ?u.2442 ?u.2445)
but is expected to have type
∀ (a : ℕ), c a ≤ ωSup c : Prop
|
exact fun x ⟨i, hi⟩ => hi ▸ le_ωSup c i
|
case left.a α : Type u inst✝¹ inst✝ : OmegaCompletePartialOrder α c : Chain α a : α h : (∀ (a_1 : ℕ), c a_1 ≤ a) ∧ ∀ ⦃a_1 : α⦄, (∀ (a : ℕ), c a ≤ a_1) → a ≤ a_1 ⊢ ∀ (a : ℕ), c a ≤ ωSup c
|
The proof fails because the lambda expression in the incorrect proof doesn't match the expected type, which should be a unary function ∀ (a : ℕ), c a ≤ ωSup c but was given as a binary function with an additional unnecessary parameter.
|
Simplify the lambda expression to directly show ∀ (a : ℕ), c a ≤ ωSup c without extra parameters.
|
herald
|
lme
|
train
|
AlgebraicGeometry.Scheme.Pullback.pullbackFstιToV_snd.lean
|
import Mathlib.AlgebraicGeometry.Gluing
import Mathlib.CategoryTheory.Limits.Opposites
import Mathlib.AlgebraicGeometry.AffineScheme
import Mathlib.CategoryTheory.Limits.Shapes.Diagonal
import Mathlib.AlgebraicGeometry.Pullbacks
open AlgebraicGeometry
open Scheme
open Pullback
open CategoryTheory CategoryTheory.Limits AlgebraicGeometry
variable {C : Type u} [Category.{v} C]
variable {X Y Z : Scheme.{u}} (𝒰 : OpenCover.{u} X) (f : X ⟶ Z) (g : Y ⟶ Z)
variable [∀ i, HasPullback (𝒰.map i ≫ f) g]
variable {X Y Z : Scheme.{u}} (𝒰 : OpenCover.{u} X) (f : X ⟶ Z) (g : Y ⟶ Z)
variable [∀ i, HasPullback (𝒰.map i ≫ f) g]
variable [∀ i, HasPullback (𝒰.map i ≫ f) g]
variable (s : PullbackCone f g)
theorem theorem_18535 (i j : 𝒰.J) :
pullbackFstιToV 𝒰 f g i j ≫ pullback.snd _ _ = pullback.fst _ _ ≫ pullback.snd _ _ := by
simp [pullbackFstιToV, p1]
|
import Mathlib.AlgebraicGeometry.Gluing
import Mathlib.CategoryTheory.Limits.Opposites
import Mathlib.AlgebraicGeometry.AffineScheme
import Mathlib.CategoryTheory.Limits.Shapes.Diagonal
import Mathlib.AlgebraicGeometry.Pullbacks
open AlgebraicGeometry
open Scheme
open Pullback
open CategoryTheory CategoryTheory.Limits AlgebraicGeometry
variable {C : Type u} [Category.{v} C]
variable {X Y Z : Scheme.{u}} (𝒰 : OpenCover.{u} X) (f : X ⟶ Z) (g : Y ⟶ Z)
variable [∀ i, HasPullback (𝒰.map i ≫ f) g]
variable {X Y Z : Scheme.{u}} (𝒰 : OpenCover.{u} X) (f : X ⟶ Z) (g : Y ⟶ Z)
variable [∀ i, HasPullback (𝒰.map i ≫ f) g]
variable [∀ i, HasPullback (𝒰.map i ≫ f) g]
variable (s : PullbackCone f g)
theorem theorem_18535 (i j : 𝒰.J) :
pullbackFstιToV 𝒰 f g i j ≫ pullback.snd _ _ = pullback.fst _ _ ≫ pullback.snd _ _ := by
simp [pullbackFstιToV]
| null |
edf1b77315333ebff8b4f41f81e62dd177c243c0815b493eda23fb0a26504a10
| null | null | null | null | null | null | 15
| 90
|
unsolved goals
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
i j : 𝒰.J
⊢ (pullbackSymmetry (pullback.fst (p1 𝒰 f g) (𝒰.map i)) (Multicoequalizer.π (gluing 𝒰 f g).diagram j)).hom ≫
(pullbackRightPullbackFstIso (p1 𝒰 f g) (𝒰.map i) (Multicoequalizer.π (gluing 𝒰 f g).diagram j)).hom ≫
pullback.snd
(Multicoequalizer.π (gluing 𝒰 f g).diagram j ≫
Multicoequalizer.desc (gluing 𝒰 f g).diagram X (fun i => pullback.fst (𝒰.map i ≫ f) g ≫ 𝒰.map i) ⋯)
(𝒰.map i) =
pullback.fst (pullback.fst (p1 𝒰 f g) (𝒰.map i)) (Multicoequalizer.π (gluing 𝒰 f g).diagram j) ≫
pullback.snd (p1 𝒰 f g) (𝒰.map i)
|
pullbackFstιToV 𝒰 f g i j ≫ pullback.snd _ _ = pullback.fst _ _ ≫ pullback.snd _ _ := by
|
X Y Z : Scheme 𝒰 : X.OpenCover f : X ⟶ Z g : Y ⟶ Z inst✝¹ inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g i j : 𝒰.J ⊢ pullbackFstιToV 𝒰 f g i j ≫ pullback.snd (pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map i) = pullback.fst (pullback.fst (p1 𝒰 f g) (𝒰.map i)) ((gluing 𝒰 f g).ι j) ≫ pullback.snd (p1 𝒰 f g) (𝒰.map i)
|
The proof fails because the `simp` tactic alone is insufficient to simplify the complex pullback expressions, particularly those involving the `pullbackFstιToV` construction and pullback symmetries.
|
Add more specific lemmas or intermediate steps to simplify the pullback expressions before applying `simp`.
|
herald
|
lme
|
train
|
HasDerivWithinAt.liminf_right_slope_norm_le.lean
|
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.LinearAlgebra.AffineSpace.Slope
import Mathlib.Analysis.Calculus.Deriv.Slope
open HasDerivWithinAt
open Topology Filter TopologicalSpace
open Filter Set
variable {𝕜 : Type u} [NontriviallyNormedField 𝕜]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace 𝕜 F]
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
variable {f f₀ f₁ g : 𝕜 → F}
variable {f' f₀' f₁' g' : F}
variable {x : 𝕜}
variable {s t : Set 𝕜}
variable {L L₁ L₂ : Filter 𝕜}
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace 𝕜 F]
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
variable {f f₀ f₁ g : 𝕜 → F}
variable {f' f₀' f₁' g' : F}
variable {x : 𝕜}
variable {s t : Set 𝕜}
variable {L L₁ L₂ : Filter 𝕜}
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
variable {f f₀ f₁ g : 𝕜 → F}
variable {f' f₀' f₁' g' : F}
variable {x : 𝕜}
variable {s t : Set 𝕜}
variable {L L₁ L₂ : Filter 𝕜}
variable {f f₀ f₁ g : 𝕜 → F}
variable {f' f₀' f₁' g' : F}
variable {x : 𝕜}
variable {s t : Set 𝕜}
variable {L L₁ L₂ : Filter 𝕜}
variable {f' f₀' f₁' g' : F}
variable {x : 𝕜}
variable {s t : Set 𝕜}
variable {L L₁ L₂ : Filter 𝕜}
variable {x : 𝕜}
variable {s t : Set 𝕜}
variable {L L₁ L₂ : Filter 𝕜}
variable {s t : Set 𝕜}
variable {L L₁ L₂ : Filter 𝕜}
variable {L L₁ L₂ : Filter 𝕜}
variable {f : ℝ → ℝ} {f' : ℝ} {s : Set ℝ} {x : ℝ} {r : ℝ}
open Metric
variable {E : Type u} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : ℝ → E} {f' : E} {s : Set ℝ}
{x r : ℝ}
theorem theorem_43318 (hf : HasDerivWithinAt f f' (Ici x) x)
(hr : ‖f'‖ < r) : ∃ᶠ z in 𝓝[>] x, (z - x)⁻¹ * (‖f z‖ - ‖f x‖) < r := by
have := (hf.Ioi_of_Ici.limsup_slope_norm_le hr).frequently
refine this.mp (Eventually.mono self_mem_nhdsWithin fun z hxz hz ↦ ?_)
rwa [Real.norm_eq_abs, abs_of_pos (sub_pos_of_lt hxz)] at hz
|
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.LinearAlgebra.AffineSpace.Slope
import Mathlib.Analysis.Calculus.Deriv.Slope
open HasDerivWithinAt
open Topology Filter TopologicalSpace
open Filter Set
variable {𝕜 : Type u} [NontriviallyNormedField 𝕜]
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace 𝕜 F]
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
variable {f f₀ f₁ g : 𝕜 → F}
variable {f' f₀' f₁' g' : F}
variable {x : 𝕜}
variable {s t : Set 𝕜}
variable {L L₁ L₂ : Filter 𝕜}
variable {F : Type v} [NormedAddCommGroup F] [NormedSpace 𝕜 F]
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
variable {f f₀ f₁ g : 𝕜 → F}
variable {f' f₀' f₁' g' : F}
variable {x : 𝕜}
variable {s t : Set 𝕜}
variable {L L₁ L₂ : Filter 𝕜}
variable {E : Type w} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
variable {f f₀ f₁ g : 𝕜 → F}
variable {f' f₀' f₁' g' : F}
variable {x : 𝕜}
variable {s t : Set 𝕜}
variable {L L₁ L₂ : Filter 𝕜}
variable {f f₀ f₁ g : 𝕜 → F}
variable {f' f₀' f₁' g' : F}
variable {x : 𝕜}
variable {s t : Set 𝕜}
variable {L L₁ L₂ : Filter 𝕜}
variable {f' f₀' f₁' g' : F}
variable {x : 𝕜}
variable {s t : Set 𝕜}
variable {L L₁ L₂ : Filter 𝕜}
variable {x : 𝕜}
variable {s t : Set 𝕜}
variable {L L₁ L₂ : Filter 𝕜}
variable {s t : Set 𝕜}
variable {L L₁ L₂ : Filter 𝕜}
variable {L L₁ L₂ : Filter 𝕜}
variable {f : ℝ → ℝ} {f' : ℝ} {s : Set ℝ} {x : ℝ} {r : ℝ}
open Metric
variable {E : Type u} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : ℝ → E} {f' : E} {s : Set ℝ}
{x r : ℝ}
theorem theorem_43318 (hf : HasDerivWithinAt f f' (Ici x) x)
(hr : ‖f'‖ < r) : ∃ᶠ z in 𝓝[>] x, (z - x)⁻¹ * (‖f z‖ - ‖f x‖) < r := by
have := hf.eventually_norm_slope_lt hr (by simp)
refine this.mp (Eventually.mono self_mem_nhdsWithin fun z hxz hz ↦ ?_)
rwa [Real.norm_eq_abs, abs_of_pos (sub_pos_of_lt hxz)] at hz
| null |
640b839b936333bafa4b5334212f8c6eaa7271c4790132098f82068cfbe7becf
| null | null | null | null | null | null | 47
| 73
|
unsolved goals
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : ℝ → E
f' : E
x r : ℝ
hf : HasDerivWithinAt f f' (Ici x) x
hr : ‖f'‖ < r
⊢ ∃ᶠ (z : ℝ) in 𝓝[>] x, (z - x)⁻¹ * (‖f z‖ - ‖f x‖) < r
|
(hr : ‖f'‖ < r) : ∃ᶠ z in 𝓝[>] x, (z - x)⁻¹ * (‖f z‖ - ‖f x‖) < r := by
|
E : Type u inst✝¹ : NormedAddCommGroup E inst✝ : NormedSpace ℝ E f : ℝ → E f' : E x r : ℝ hf : HasDerivWithinAt f f' (Ici x) x hr : ‖f'‖ < r ⊢ ∃ᶠ (z : ℝ) in 𝓝[>] x, (z - x)⁻¹ * (‖f z‖ - ‖f x‖) < r
|
The incorrect proof fails because it uses `hf.eventually_norm_slope_lt` which doesn't directly apply to the right-neighborhood condition (𝓝[>] x) needed in the theorem. The theorem requires working specifically with the right limit (Ioi x) rather than the closed interval (Ici x).
|
Use `hf.Ioi_of_Ici` to convert the derivative condition to the open interval before applying slope comparison.
|
herald
|
lme
|
train
|
tendsto_exp_div_rpow_atTop.lean
|
import Mathlib.Analysis.SpecialFunctions.Pow.NNReal
import Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics
open scoped Classical
open Real Topology NNReal ENNReal Filter ComplexConjugate Finset Set
open Real Filter
open Asymptotics in
theorem theorem_21772 (s : ℝ) : Tendsto (fun x : ℝ => exp x / x ^ s) atTop atTop := by
cases' archimedean_iff_nat_lt.1 Real.instArchimedean s with n hn
refine tendsto_atTop_mono' _ ?_ (tendsto_exp_div_pow_atTop n)
filter_upwards [eventually_gt_atTop (0 : ℝ), eventually_ge_atTop (1 : ℝ)] with x hx₀ hx₁
rw [div_le_div_left (exp_pos _) (pow_pos hx₀ _) (rpow_pos_of_pos hx₀ _), ← Real.rpow_natCast]
exact rpow_le_rpow_of_exponent_le hx₁ hn.le
|
import Mathlib.Analysis.SpecialFunctions.Pow.NNReal
import Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics
open scoped Classical
open Real Topology NNReal ENNReal Filter ComplexConjugate Finset Set
open Real Filter
open Asymptotics in
theorem theorem_21772 (s : ℝ) : Tendsto (fun x : ℝ => exp x / x ^ s) atTop atTop := by
obtain ⟨n, hn⟩ := exists_nat_ge s
refine tendsto_atTop_mono' _ ?_ (tendsto_exp_div_pow_atTop n)
filter_upwards [eventually_gt_atTop (0 : ℝ), eventually_ge_atTop (1 : ℝ)] with x hx₀ hx₁
rw [div_le_div_left (exp_pos _) (pow_pos hx₀ _) (rpow_pos_of_pos hx₀ _), ← Real.rpow_natCast]
exact rpow_le_rpow_of_exponent_le hx₁ hn.le
| null |
e6097cc7dea7dcae6a113b7b47993283de13f77cd592257bd2e1525efb615616
| null | null | null | null | null | null | 13
| 8
|
overloaded, errors
15:40 Invalid field `le`: The environment does not contain `_private.Mathlib.Data.Real.Basic.0.Real.le.le`
hn
has type
Real.le✝ s ↑n
15:40 Invalid field `le`: The environment does not contain `_private.Mathlib.Data.Real.Basic.0.Real.le.le`
hn
has type
Real.le✝ s ↑n
15:40 Invalid field `le`: The environment does not contain `_private.Mathlib.Data.Real.Basic.0.Real.le.le`
hn
has type
Real.le✝ s ↑n
|
exact rpow_le_rpow_of_exponent_le hx₁ hn.le
|
case h s : ℝ n : ℕ hn : s ≤ ↑n x : ℝ hx₀ : 0 < x hx₁ : 1 ≤ x ⊢ x ^ s ≤ x ^ ↑n
|
The proof fails because it attempts to use `exists_nat_ge` from Order.Bounds.Basic which creates a problematic implicit coercion to find a natural number upper bound (Real.le.le), rather than using the correct archimedean property instance for reals.
|
Use `archimedean_iff_nat_lt` with `Real.instArchimedean` to properly handle the real-to-natural-number coercion.
|
herald
|
lme
|
train
|
IsLindelof.elim_nhds_subcover.lean
|
import Mathlib.Topology.Bases
import Mathlib.Order.Filter.CountableInter
import Mathlib.Topology.Compactness.SigmaCompact
import Mathlib.Topology.Compactness.Lindelof
open IsLindelof
open Set Filter Topology TopologicalSpace
variable {X : Type u} {Y : Type v} {ι : Type*}
variable [TopologicalSpace X] [TopologicalSpace Y] {s t : Set X}
variable [TopologicalSpace X] [TopologicalSpace Y] {s t : Set X}
theorem theorem_29954 (hs : IsLindelof s) (U : X → Set X)
(hU : ∀ x ∈ s, U x ∈ 𝓝 x) :
∃ t : Set X, t.Countable ∧ (∀ x ∈ t, x ∈ s) ∧ s ⊆ ⋃ x ∈ t, U x := by
let ⟨t, ⟨htc, htsub⟩⟩ := hs.elim_nhds_subcover' (fun x _ ↦ U x) hU
refine ⟨↑t, Countable.image htc Subtype.val, ?_⟩
constructor
· intro _
simp only [mem_image, Subtype.exists, exists_and_right, exists_eq_right, forall_exists_index]
tauto
· have : ⋃ x ∈ t, U ↑x = ⋃ x ∈ Subtype.val '' t, U x := biUnion_image.symm
rwa [← this]
|
import Mathlib.Topology.Bases
import Mathlib.Order.Filter.CountableInter
import Mathlib.Topology.Compactness.SigmaCompact
import Mathlib.Topology.Compactness.Lindelof
open IsLindelof
open Set Filter Topology TopologicalSpace
variable {X : Type u} {Y : Type v} {ι : Type*}
variable [TopologicalSpace X] [TopologicalSpace Y] {s t : Set X}
variable [TopologicalSpace X] [TopologicalSpace Y] {s t : Set X}
theorem theorem_29954 (hs : IsLindelof s) (U : X → Set X)
(hU : ∀ x ∈ s, U x ∈ 𝓝 x) :
∃ t : Set X, t.Countable ∧ (∀ x ∈ t, x ∈ s) ∧ s ⊆ ⋃ x ∈ t, U x := by
let ⟨t, ⟨htc, htsub⟩⟩ := hs.elim_nhds_subcover' (fun x _ ↦ U x) hU
refine ⟨↑t, Countable.image htc Subtype.val, ?_⟩
constructor
· intro _
simp only [mem_image, Subtype.exists, exists_and_right, exists_eq_right, forall_exists_index]
tauto
have : (⋃ x ∈ t, U (x : X)) = ⋃ x ∈ (↑t : Set X), U x := by
rwa [← this]
| null |
32ef1d627a31fbf6446a89b0b7b0a33f1d591b18fd24b5606c0db57ec03d924a
| null | null | null | null | null | null | 10
| 70
|
unsolved goals
case right
X : Type u
inst✝¹ inst✝ : TopologicalSpace X
s : Set X
hs : IsLindelof s
U : X → Set X
hU : ∀ x ∈ s, U x ∈ 𝓝 x
t : Set ↑s
htc : t.Countable
htsub : s ⊆ ⋃ x ∈ t, U ↑x
this : ⋃ x ∈ t, U ↑x = ⋃ x ∈ Subtype.val '' t, U x
⊢ s ⊆ ⋃ x ∈ Subtype.val '' t, U x
|
∃ t : Set X, t.Countable ∧ (∀ x ∈ t, x ∈ s) ∧ s ⊆ ⋃ x ∈ t, U x := by
|
X : Type u inst✝¹ inst✝ : TopologicalSpace X s : Set X hs : IsLindelof s U : X → Set X hU : ∀ x ∈ s, U x ∈ 𝓝 x ⊢ ∃ t, t.Countable ∧ (∀ x ∈ t, x ∈ s) ∧ s ⊆ ⋃ x ∈ t, U x
|
The proof fails because it doesn't properly handle the subset relation between unions. The last `have` statement creates an equality, but then tries to rewrite with it incorrectly.
|
Use the created equality to rewrite the goal directly from `htsub` instead of attempting an unnecessary rewrite.
|
herald
|
lme
|
train
|
HomologicalComplex.XIsoOfEq_inv_comp_d.lean
|
import Mathlib.Algebra.Homology.ComplexShape
import Mathlib.CategoryTheory.Subobject.Limits
import Mathlib.CategoryTheory.GradedObject
import Mathlib.Algebra.Homology.ShortComplex.Basic
import Mathlib.Algebra.Homology.HomologicalComplex
open HomologicalComplex
open CategoryTheory CategoryTheory.Category CategoryTheory.Limits
variable {ι : Type*}
variable (V : Type u) [Category.{v} V] [HasZeroMorphisms V]
variable (V : Type u) [Category.{v} V] [HasZeroMorphisms V]
variable {V} {c : ComplexShape ι}
theorem theorem_40848 (K : HomologicalComplex V c) {p₂ p₁ : ι} (h : p₂ = p₁) (p₃ : ι) :
(K.XIsoOfEq h).inv ≫ K.d p₂ p₃ = K.d p₁ p₃ := by
subst h; simp
|
import Mathlib.Algebra.Homology.ComplexShape
import Mathlib.CategoryTheory.Subobject.Limits
import Mathlib.CategoryTheory.GradedObject
import Mathlib.Algebra.Homology.ShortComplex.Basic
import Mathlib.Algebra.Homology.HomologicalComplex
open HomologicalComplex
open CategoryTheory CategoryTheory.Category CategoryTheory.Limits
variable {ι : Type*}
variable (V : Type u) [Category.{v} V] [HasZeroMorphisms V]
variable (V : Type u) [Category.{v} V] [HasZeroMorphisms V]
variable {V} {c : ComplexShape ι}
theorem theorem_40848 (K : HomologicalComplex V c) {p₂ p₁ : ι} (h : p₂ = p₁) (p₃ : ι) :
(K.XIsoOfEq h).inv ≫ K.d p₂ p₃ = K.d p₁ p₃ := by
dsimp [XIsoOfEq]; simp
| null |
84d4ef5293087bb5535c9f1c400b006758fd02d5b130fb9a97b8dbb33ca76b48
| null | null | null | null | null | null | 11
| 20
|
simp made no progress
|
dsimp [XIsoOfEq]; simp
|
ι : Type u_1 V : Type u inst✝¹ : Category.{v, u} V inst✝ : HasZeroMorphisms V c : ComplexShape ι K : HomologicalComplex V c p₂ p₁ : ι h : p₂ = p₁ p₃ : ι ⊢ eqToHom ⋯ ≫ K.d p₂ p₃ = K.d p₁ p₃
|
The proof fails because 'dsimp [XIsoOfEq]' simplifies the goal to an eqToHom expression, but 'simp' cannot further simplify it without knowing p₂ = p₁.
|
First substitute the equality h before simplifying to allow simp to make progress.
|
herald
|
lme
|
train
|
List.findIdxs_cons.lean
|
import Batteries.Control.ForInStep.Lemmas
import Batteries.Data.List.Basic
import Batteries.Tactic.Init
import Batteries.Tactic.Alias
import Batteries.Data.List.Lemmas
open List
open Nat
variable [BEq α]
variable [BEq α]
variable [LawfulBEq α]
theorem theorem_20771 :
(x :: xs : List α).findIdxs p =
bif p x then 0 :: (xs.findIdxs p).map (· + 1) else (xs.findIdxs p).map (· + 1) := by
dsimp [findIdxs]
rw [cond_eq_if]
split <;>
· simp only [Nat.zero_add, foldrIdx_start, Nat.add_zero, cons.injEq, true_and]
apply findIdxs_cons_aux
|
import Batteries.Control.ForInStep.Lemmas
import Batteries.Data.List.Basic
import Batteries.Tactic.Init
import Batteries.Tactic.Alias
import Batteries.Data.List.Lemmas
open List
open Nat
variable [BEq α]
variable [BEq α]
variable [LawfulBEq α]
theorem theorem_20771 :
(x :: xs : List α).findIdxs p =
bif p x then 0 :: (xs.findIdxs p).map (· + 1) else (xs.findIdxs p).map (· + 1) := by
dsimp [findIdxs]
rw [cond_eq_if]
split <;>
· simp only [Nat.zero_add, foldrIdx_start, Nat.add_zero, cons.injEq, true_and]
rfl
| null |
3054c2eb429a30f30e6f0b3b3a031b46376ecfbd30f56bc86f7089883e2a109c
| null | null | null | null | null | null | 15
| 4
|
tactic 'rfl' failed, the left-hand side
foldrIdx (fun i a is => if p a = true then (i + 0 + 1) :: is else is) [] xs
is not definitionally equal to the right-hand side
map (fun x => x + 1) (foldrIdx (fun i a is => if p a = true then (i + 0) :: is else is) [] xs)
case isTrue
α : Type u_1
inst✝² inst✝¹ : BEq α
inst✝ : LawfulBEq α
x : α
xs : List α
p : α → Bool
h✝ : p x = true
⊢ foldrIdx (fun i a is => if p a = true then (i + 0 + 1) :: is else is) [] xs =
map (fun x => x + 1) (foldrIdx (fun i a is => if p a = true then (i + 0) :: is else is) [] xs)
|
rfl
|
case isFalse α : Type u_1 inst✝² inst✝¹ : BEq α inst✝ : LawfulBEq α x : α xs : List α p : α → Bool h✝ : ¬p x = true ⊢ foldrIdx (fun i a is => if p a = true then (i + 0 + 1) :: is else is) [] xs = map (fun x => x + 1) (foldrIdx (fun i a is => if p a = true then (i + 0) :: is else is) [] xs)
|
The proof fails because the 'rfl' tactic cannot automatically prove the equality between the two forms of foldrIdx expressions, particularly when dealing with the conditional branches and index arithmetic.
|
Instead of using 'rfl', invoke a lemma (findIdxs_cons_aux) that specifically handles the recursive case of findIdxs.
|
herald
|
lme
|
train
|
Nat.iSup_le_succ.lean
|
import Mathlib.Order.ConditionallyCompleteLattice.Finset
import Mathlib.Order.Interval.Finset.Nat
import Mathlib.Data.Nat.Lattice
open Nat
open Set
open scoped Classical
variable {α : Type*} [CompleteLattice α]
theorem theorem_35856 (u : ℕ → α) (n : ℕ) : ⨆ k ≤ n + 1, u k = (⨆ k ≤ n, u k) ⊔ u (n + 1) := by
simp_rw [← Nat.lt_succ_iff, iSup_lt_succ]
|
import Mathlib.Order.ConditionallyCompleteLattice.Finset
import Mathlib.Order.Interval.Finset.Nat
import Mathlib.Data.Nat.Lattice
open Nat
open Set
open scoped Classical
variable {α : Type*} [CompleteLattice α]
theorem theorem_35856 (u : ℕ → α) (n : ℕ) : ⨆ k ≤ n + 1, u k = (⨆ k ≤ n, u k) ⊔ u (n + 1) := by
simp [iSup_or, Nat.lt_succ_iff_lt_or_eq]
| null |
29b3c555b501ee56cab734db0c97fa4d045457bcf6d29887626d3a839525c9e7
| null | null | null | null | null | null | 8
| 2
|
simp made no progress
|
simp [iSup_or, Nat.lt_succ_iff_lt_or_eq]
|
α : Type u_1 inst✝ : CompleteLattice α u : ℕ → α n : ℕ ⊢ ⨆ k, ⨆ (_ : k ≤ n + 1), u k = (⨆ k, ⨆ (_ : k ≤ n), u k) ⊔ u (n + 1)
|
The proof fails because `simp` cannot simplify the goal using only `iSup_or` and `Nat.lt_succ_iff_lt_or_eq`; these lemmas don't directly match the structure of the goal about supremums over natural number bounds.
|
Use `simp_rw` with `Nat.lt_succ_iff` and `iSup_lt_succ` to rewrite the goal in a form that matches existing lemmas about supremums and successor relations.
|
herald
|
lme
|
train
|
List.mem_enum_iff_get?.lean
|
import Batteries.Tactic.Alias
import Mathlib.Tactic.TypeStar
import Mathlib.Data.Nat.Notation
import Mathlib.Data.List.Enum
open List
variable {α β : Type*}
theorem theorem_13170 {x : ℕ × α} {l : List α} : x ∈ enum l ↔ l.get? x.1 = x.2 := by
simp [mem_enum_iff_getElem?]
|
import Batteries.Tactic.Alias
import Mathlib.Tactic.TypeStar
import Mathlib.Data.Nat.Notation
import Mathlib.Data.List.Enum
open List
variable {α β : Type*}
theorem theorem_13170 {x : ℕ × α} {l : List α} : x ∈ enum l ↔ l.get? x.1 = x.2 := by
rw [List.mem_enum, List.get?_eq_some]
| null |
51bbb197b0ae82302e6abc8ed51c725111702431165b31ba3e018f6172f8b808
| null | null | null | null | null | null | 6
| 6
|
tactic 'rewrite' failed, equality or iff proof expected
?m.211 < length ?m.212 ∧ ?m.210 = ?m.212[?m.211]
α : Type u_1
x : ℕ × α
l : List α
⊢ x ∈ l.enum ↔ l.get? x.1 = some x.2
|
rw [List.mem_enum, List.get?_eq_some]
|
α : Type u_1 x : ℕ × α l : List α ⊢ x ∈ l.enum ↔ l.get? x.1 = some x.2
|
The proof fails because the rewrite tactic cannot directly apply `List.mem_enum` and `List.get?_eq_some` since they don't match the goal's structure and require additional simplification.
|
Use a simp lemma specifically designed for enum membership (`mem_enum_iff_getElem?`) to simplify the goal.
|
herald
|
lme
|
train
|
Fin.cons_injective_iff.lean
|
import Mathlib.Data.Fin.Basic
import Mathlib.Data.Nat.Find
import Batteries.Data.Fin.Lemmas
import Mathlib.Data.Fin.Tuple.Basic
open Fin
variable {m n : ℕ}
open Function
variable {α : Fin (n + 1) → Type u} (x : α 0) (q : ∀ i, α i) (p : ∀ i : Fin n, α i.succ) (i : Fin n)
(y : α i.succ) (z : α 0)
theorem theorem_17650 {α} {x₀ : α} {x : Fin n → α} :
Function.Injective (cons x₀ x : Fin n.succ → α) ↔ x₀ ∉ Set.range x ∧ Function.Injective x := by
refine ⟨fun h ↦ ⟨?_, ?_⟩, fun h ↦ cons_injective_of_injective h.1 h.2⟩
· rintro ⟨i, hi⟩
replace h := @h i.succ 0
simp [hi, succ_ne_zero] at h
· simpa [Function.comp] using h.comp (Fin.succ_injective _)
|
import Mathlib.Data.Fin.Basic
import Mathlib.Data.Nat.Find
import Batteries.Data.Fin.Lemmas
import Mathlib.Data.Fin.Tuple.Basic
open Fin
variable {m n : ℕ}
open Function
variable {α : Fin (n + 1) → Type u} (x : α 0) (q : ∀ i, α i) (p : ∀ i : Fin n, α i.succ) (i : Fin n)
(y : α i.succ) (z : α 0)
theorem theorem_17650 {α} {x₀ : α} {x : Fin n → α} :
Function.Injective (cons x₀ x : Fin n.succ → α) ↔ x₀ ∉ Set.range x ∧ Function.Injective x := by
refine ⟨fun h ↦ ⟨?_, ?_⟩, fun h ↦ cons_injective_of_injective h.1 h.2⟩
· rintro ⟨i, hi⟩
have := h (by simp [hi])
simp [hi, succ_ne_zero] at h
· simpa [Function.comp] using h.comp (Fin.succ_injective _)
| null |
09f7f80e6d5429d74cb2c40c63421f13682c1434ee09a84801611a5117ea7d2f
| null | null | null | null | null | null | 12
| 15
|
unsolved goals
n : ℕ
α : Type u_1
x₀ : α
x : Fin n → α
h : Injective (cons x₀ x)
i : Fin n
hi : x i = x₀
⊢ cons x₀ x ?m.600 = cons x₀ x ?m.601
|
have := h (by simp [hi])
|
n : ℕ α : Type u_1 x₀ : α x : Fin n → α h : Injective (cons x₀ x) i : Fin n hi : x i = x₀ ⊢ cons x₀ x ?m.600 = cons x₀ x ?m.601
|
The proof fails because the initial approach incorrectly uses `h (by simp [hi])` without specifying which indices to compare, leaving metavariables unresolved.
|
Explicitly compare specific indices (i.succ and 0) when using injectivity to resolve the goal.
|
herald
|
lme
|
train
|
List.dropLast_eq_dropLastTR.lean
|
import Init.Data.Array.Lemmas
import Init.Data.List.Impl
open List
theorem theorem_6886 : @dropLast = @dropLastTR := by
funext α l; simp [dropLastTR]
|
import Init.Data.Array.Lemmas
import Init.Data.List.Impl
open List
theorem theorem_6886 : @dropLast = @dropLastTR := by
exact funext (fun l => by induction l <;> simp [dropLast, dropLastTR])
| null |
bc3fb9b984e965d8b0aa486e994ba2260500067111957318ee17d907317cebe3
| null | null | null | null | null | null | 5
| 28
|
tactic 'induction' failed, major premise type is not an inductive type
Type u_1
Explanation: the 'induction' tactic is for constructor-based reasoning as well as for applying custom induction principles with a 'using' clause or a registered '@[induction_eliminator]' theorem. The above type neither is an inductive type nor has a registered theorem.
Type universes are not inductive types, and type-constructor-based reasoning is not possible. This is a strong limitation. According to Lean's underlying theory, the only provable distinguishing feature of types is their cardinalities.
l : Type u_1
⊢ dropLast = dropLastTR
|
exact funext (fun l => by induction l <;> simp [dropLast, dropLastTR])
|
l : Type u_1 ⊢ dropLast = dropLastTR
|
The proof fails because it attempts to use the 'induction' tactic on a type variable (Type u_1), which is not an inductive type and cannot be reasoned about by induction.
|
Replace the inductive approach with a direct proof using functional extensionality and simplification.
|
herald
|
lme
|
train
|
Complex.restrictScalars_one_smulRight.lean
|
import Mathlib.Data.Complex.Module
import Mathlib.Data.Complex.Order
import Mathlib.Data.Complex.Exponential
import Mathlib.Analysis.RCLike.Basic
import Mathlib.Topology.Algebra.InfiniteSum.Module
import Mathlib.Topology.Instances.RealVectorSpace
import Mathlib.Analysis.Complex.Basic
open Complex
variable {z : ℂ}
open ComplexConjugate Topology Filter
variable {E : Type*} [SeminormedAddCommGroup E] [NormedSpace ℂ E]
open ContinuousLinearMap
theorem theorem_24256 (x : ℂ) :
ContinuousLinearMap.restrictScalars ℝ ((1 : ℂ →L[ℂ] ℂ).smulRight x : ℂ →L[ℂ] ℂ) =
x • (1 : ℂ →L[ℝ] ℂ) := by
ext1 z
dsimp
apply mul_comm
|
import Mathlib.Data.Complex.Module
import Mathlib.Data.Complex.Order
import Mathlib.Data.Complex.Exponential
import Mathlib.Analysis.RCLike.Basic
import Mathlib.Topology.Algebra.InfiniteSum.Module
import Mathlib.Topology.Instances.RealVectorSpace
import Mathlib.Analysis.Complex.Basic
open Complex
variable {z : ℂ}
open ComplexConjugate Topology Filter
variable {E : Type*} [SeminormedAddCommGroup E] [NormedSpace ℂ E]
open ContinuousLinearMap
theorem theorem_24256 (x : ℂ) :
ContinuousLinearMap.restrictScalars ℝ ((1 : ℂ →L[ℂ] ℂ).smulRight x : ℂ →L[ℂ] ℂ) =
x • (1 : ℂ →L[ℝ] ℂ) := by
ext1 z
simp [ContinuousLinearMap.smulRight_apply, ContinuousLinearMap.restrictScalars_apply, ContinuousLinearMap.smul_apply]
apply mul_comm
| null |
f13edb38c8de6769d1a80fba946c7d28cb308f58880e41e538be9707d5bcc421
| null | null | null | null | null | null | 12
| 45
|
unknown constant 'ContinuousLinearMap.restrictScalars_apply'
|
simp [ContinuousLinearMap.smulRight_apply, ContinuousLinearMap.restrictScalars_apply, ContinuousLinearMap.smul_apply]
|
x : ℂ ⊢ restrictScalars ℝ (smulRight 1 x) = x • 1
|
The proof fails because it tries to use `ContinuousLinearMap.restrictScalars_apply` which is not a known lemma in the current context.
|
Replace the problematic lemma with simpler tactics like `dsimp` to unfold definitions.
|
herald
|
lme
|
train
|
CategoryTheory.ShiftedHom.id_map.lean
|
import Mathlib.CategoryTheory.Shift.CommShift
import Mathlib.CategoryTheory.Preadditive.AdditiveFunctor
import Mathlib.CategoryTheory.Shift.ShiftedHom
open CategoryTheory
open ShiftedHom
open Category
variable {C : Type*} [Category C] {D : Type*} [Category D] {E : Type*} [Category E]
{M : Type*} [AddMonoid M] [HasShift C M] [HasShift D M] [HasShift E M]
variable {X Y Z T : C}
variable [Preadditive C]
variable (X Y) in
@[simp]
lemma mk₀_zero (m₀ : M) (hm₀ : m₀ = 0) : mk₀ m₀ hm₀ (0 : X ⟶ Y) = 0 := by simp [mk₀]
variable (Z) in
@[simp]
lemma comp_zero [∀ (a : M), (shiftFunctor C a).PreservesZeroMorphisms]
{a : M} (β : ShiftedHom X Y a) {b c : M} (h : b + a = c) :
β.comp (0 : ShiftedHom Y Z b) h = 0 := by
rw [comp, Functor.map_zero, Limits.zero_comp, Limits.comp_zero]
variable (X) in
@[simp]
lemma zero_comp (a : M) {b c : M} (β : ShiftedHom Y Z b) (h : b + a = c) :
(0 : ShiftedHom X Y a).comp β h = 0 := by
rw [comp, Limits.zero_comp]
theorem theorem_35713 {a : M} (f : ShiftedHom X Y a) : f.map (𝟭 C) = f := by
simp [map, Functor.commShiftIso, Functor.CommShift.iso]
|
import Mathlib.CategoryTheory.Shift.CommShift
import Mathlib.CategoryTheory.Preadditive.AdditiveFunctor
import Mathlib.CategoryTheory.Shift.ShiftedHom
open CategoryTheory
open ShiftedHom
open Category
variable {C : Type*} [Category C] {D : Type*} [Category D] {E : Type*} [Category E]
{M : Type*} [AddMonoid M] [HasShift C M] [HasShift D M] [HasShift E M]
variable {X Y Z T : C}
variable [Preadditive C]
variable (X Y) in
@[simp]
lemma mk₀_zero (m₀ : M) (hm₀ : m₀ = 0) : mk₀ m₀ hm₀ (0 : X ⟶ Y) = 0 := by simp [mk₀]
variable (Z) in
@[simp]
lemma comp_zero [∀ (a : M), (shiftFunctor C a).PreservesZeroMorphisms]
{a : M} (β : ShiftedHom X Y a) {b c : M} (h : b + a = c) :
β.comp (0 : ShiftedHom Y Z b) h = 0 := by
rw [comp, Functor.map_zero, Limits.zero_comp, Limits.comp_zero]
variable (X) in
@[simp]
lemma zero_comp (a : M) {b c : M} (β : ShiftedHom Y Z b) (h : b + a = c) :
(0 : ShiftedHom X Y a).comp β h = 0 := by
rw [comp, Limits.zero_comp]
theorem theorem_35713 {a : M} (f : ShiftedHom X Y a) : f.map (𝟭 C) = f := by
simp [map, Functor.commShiftIso, Functor.CommShift.iso]
| null |
0b87f5f2c3c43a5a276519a210da246833fec6ba2e818962a8be8aefcbc57387
| null | null | null | null | null | null | 22
| 12
|
tactic 'rewrite' failed, did not find instance of the pattern in the target expression
(Functor.toPrefunctor ?F).map 0
C : Type u_1
inst✝³ : Category.{u_5, u_1} C
M : Type u_4
inst✝² : AddMonoid M
inst✝¹ : HasShift C M
X Y Z : C
inst✝ : Preadditive C
a b c : M
β : ShiftedHom Y Z b
h : b + a = c
⊢ 0 ≫ (shiftFunctor C a).map β ≫ (shiftFunctorAdd' C b a c h).inv.app Z = 0
|
rw [comp, Functor.map_zero, Limits.zero_comp, Limits.comp_zero]
|
C : Type u_1 inst✝³ : Category.{u_5, u_1} C M : Type u_4 inst✝² : AddMonoid M inst✝¹ : HasShift C M X Y Z : C inst✝ : Preadditive C a b c : M β : ShiftedHom Y Z b h : b + a = c ⊢ 0 ≫ (shiftFunctor C a).map β ≫ (shiftFunctorAdd' C b a c h).inv.app Z = 0
|
The proof fails because it attempts to rewrite using `Functor.map_zero` when the target expression doesn't contain this pattern, instead having the zero morphism composed with other terms.
|
Simplify the proof by directly applying `zero_comp` lemma which handles the zero morphism composition case.
|
herald
|
lme
|
train
|
mem_adjoin_of_dvd_coeff_of_dvd_aeval.lean
|
import Mathlib.Data.Nat.Choose.Dvd
import Mathlib.RingTheory.IntegralClosure.IntegrallyClosed
import Mathlib.RingTheory.Norm.Basic
import Mathlib.RingTheory.Polynomial.Cyclotomic.Expand
import Mathlib.RingTheory.Polynomial.Eisenstein.IsIntegral
variable {R : Type u}
open Ideal Algebra Finset
open scoped Polynomial
variable (p : ℕ)
open Polynomial
variable {K : Type v} {L : Type z} {p : R} [CommRing R] [Field K] [Field L]
variable [Algebra K L] [Algebra R L] [Algebra R K] [IsScalarTower R K L] [Algebra.IsSeparable K L]
variable [IsDomain R] [IsFractionRing R K] [IsIntegrallyClosed R]
variable [Algebra K L] [Algebra R L] [Algebra R K] [IsScalarTower R K L] [Algebra.IsSeparable K L]
variable [IsDomain R] [IsFractionRing R K] [IsIntegrallyClosed R]
variable [IsDomain R] [IsFractionRing R K] [IsIntegrallyClosed R]
open IsIntegrallyClosed PowerBasis Nat Polynomial IsScalarTower
theorem theorem_6572 {A B : Type*} [CommSemiring A] [CommRing B]
[Algebra A B] [NoZeroSMulDivisors A B] {Q : A[X]} {p : A} {x z : B} (hp : p ≠ 0)
(hQ : ∀ i ∈ range (Q.natDegree + 1), p ∣ Q.coeff i) (hz : aeval x Q = p • z) :
z ∈ adjoin A ({x} : Set B) := by
choose! f hf using hQ
rw [aeval_eq_sum_range, sum_range] at hz
conv_lhs at hz =>
congr
next => skip
ext i
rw [hf i (mem_range.2 (Fin.is_lt i)), ← smul_smul]
rw [← smul_sum] at hz
rw [← smul_right_injective _ hp hz]
exact
Subalgebra.sum_mem _ fun _ _ =>
Subalgebra.smul_mem _ (Subalgebra.pow_mem _ (subset_adjoin (Set.mem_singleton _)) _) _
|
import Mathlib.Data.Nat.Choose.Dvd
import Mathlib.RingTheory.IntegralClosure.IntegrallyClosed
import Mathlib.RingTheory.Norm.Basic
import Mathlib.RingTheory.Polynomial.Cyclotomic.Expand
import Mathlib.RingTheory.Polynomial.Eisenstein.IsIntegral
variable {R : Type u}
open Ideal Algebra Finset
open scoped Polynomial
variable (p : ℕ)
open Polynomial
variable {K : Type v} {L : Type z} {p : R} [CommRing R] [Field K] [Field L]
variable [Algebra K L] [Algebra R L] [Algebra R K] [IsScalarTower R K L] [Algebra.IsSeparable K L]
variable [IsDomain R] [IsFractionRing R K] [IsIntegrallyClosed R]
variable [Algebra K L] [Algebra R L] [Algebra R K] [IsScalarTower R K L] [Algebra.IsSeparable K L]
variable [IsDomain R] [IsFractionRing R K] [IsIntegrallyClosed R]
variable [IsDomain R] [IsFractionRing R K] [IsIntegrallyClosed R]
open IsIntegrallyClosed PowerBasis Nat Polynomial IsScalarTower
theorem theorem_6572 {A B : Type*} [CommSemiring A] [CommRing B]
[Algebra A B] [NoZeroSMulDivisors A B] {Q : A[X]} {p : A} {x z : B} (hp : p ≠ 0)
(hQ : ∀ i ∈ range (Q.natDegree + 1), p ∣ Q.coeff i) (hz : aeval x Q = p • z) :
z ∈ adjoin A ({x} : Set B) := by
choose! f hf using hQ
rw [aeval_eq_sum_range, sum_range] at hz
conv_lhs at hz =>
congr
next => skip
ext i
rw [hf i (mem_range.2 (Fin.is_lt i)), ← smul_smul]
rw [← smul_sum] at hz
rw [← smul_right_injective _ hp hz]
exact
Subalgebra.sum_mem _ fun _ _ =>
Subalgebra.smul_mem _ (Subalgebra.pow_mem _ (subset_adjoin (Set.mem_singleton x)) (i : ℕ)) (f i)
| null |
43abea0330c05492f8048fd055f330230a4f03f179d7ed2e3f8a947ccc8ae168
| null | null | null | null | null | null | 31
| 89
|
unknown identifier 'i'
|
Subalgebra.smul_mem _ (Subalgebra.pow_mem _ (subset_adjoin (Set.mem_singleton x)) (i : ℕ)) (f i)
|
A : Type u_1 B : Type u_2 inst✝³ : CommSemiring A inst✝² : CommRing B inst✝¹ : Algebra A B inst✝ : NoZeroSMulDivisors A B Q : A[X] p : A x z : B hp : p ≠ 0 f : ℕ → A hz : p • ∑ x_1, f ↑x_1 • x ^ ↑x_1 = p • z hf : ∀ i ∈ range (Q.natDegree + 1), Q.coeff i = p * f i ⊢ ∑ x_1, f ↑x_1 • x ^ ↑x_1 ∈ adjoin A {x}
|
The proof fails because the variable 'i' is referenced in the final exact statement but it is out of scope - it was only visible within the conv_lhs block.
|
Replace the specific variable 'i' with a placeholder or lambda-bound variable in the final exact statement to maintain correct scope.
|
herald
|
lme
|
train
|
ENNReal.Ioo_zero_top_eq_iUnion_Ico_zpow.lean
|
import Mathlib.Data.ENNReal.Operations
import Mathlib.Data.ENNReal.Inv
open ENNReal
open Set NNReal
variable {a b c d : ℝ≥0∞} {r p q : ℝ≥0}
theorem theorem_388 {y : ℝ≥0∞} (hy : 1 < y) (h'y : y ≠ ⊤) :
Ioo (0 : ℝ≥0∞) (∞ : ℝ≥0∞) = ⋃ n : ℤ, Ico (y ^ n) (y ^ (n + 1)) := by
ext x
simp only [mem_iUnion, mem_Ioo, mem_Ico]
constructor
· rintro ⟨hx, h'x⟩
exact exists_mem_Ico_zpow hx.ne' h'x.ne hy h'y
· rintro ⟨n, hn, h'n⟩
constructor
· apply lt_of_lt_of_le _ hn
exact ENNReal.zpow_pos (zero_lt_one.trans hy).ne' h'y _
· apply lt_trans h'n _
exact ENNReal.zpow_lt_top (zero_lt_one.trans hy).ne' h'y _
|
import Mathlib.Data.ENNReal.Operations
import Mathlib.Data.ENNReal.Inv
open ENNReal
open Set NNReal
variable {a b c d : ℝ≥0∞} {r p q : ℝ≥0}
theorem theorem_388 {y : ℝ≥0∞} (hy : 1 < y) (h'y : y ≠ ⊤) :
Ioo (0 : ℝ≥0∞) (∞ : ℝ≥0∞) = ⋃ n : ℤ, Ico (y ^ n) (y ^ (n + 1)) := by
ext x
simp only [mem_iUnion, mem_Ioo, mem_Ico]
constructor
· rintro ⟨hx, h'x⟩
obtain ⟨n, hn, h'n⟩ := ENNReal.exists_mem_Ico_zpow hy h'y (ne_of_gt hx) (ne_of_lt h'x)
· rintro ⟨n, hn, h'n⟩
constructor
· apply lt_of_lt_of_le _ hn
exact ENNReal.zpow_pos (zero_lt_one.trans hy).ne' h'y _
· apply lt_trans h'n _
exact ENNReal.zpow_lt_top (zero_lt_one.trans hy).ne' h'y _
| null |
d5fac205433a26918d95af7bf4a2018da752346be5974e0cc3e677f925a2c63f
| null | null | null | null | null | null | 12
| 55
|
Application type mismatch: In the application
ENNReal.exists_mem_Ico_zpow hy
the argument
hy
has type
1 < y : Prop
but is expected to have type
?m.1231 ≠ 0 : Prop
|
obtain ⟨n, hn, h'n⟩ := ENNReal.exists_mem_Ico_zpow hy h'y (ne_of_gt hx) (ne_of_lt h'x)
|
y : ℝ≥0∞ hy : 1 < y h'y : y ≠ ⊤ ⊢ Ioo 0 ⊤ = ⋃ n, Ico (y ^ n) (y ^ (n + 1))
|
The proof fails because `ENNReal.exists_mem_Ico_zpow` expects four arguments in the order: `(hx : x ≠ 0) (hx' : x ≠ ⊤) (hy : 1 < y) (h'y : y ≠ ⊤)`, but the incorrect proof passes the arguments out of order.
|
Pass the arguments in correct order, first showing x is neither 0 nor ∞, then showing y is greater than 1 and finite.
|
herald
|
lme
|
train
|
CochainComplex.mappingCone.inr_snd.lean
|
import Mathlib.Algebra.Homology.HomotopyCategory.HomComplex
import Mathlib.Algebra.Homology.HomotopyCofiber
import Mathlib.Algebra.Homology.HomotopyCategory.MappingCone
open CochainComplex
open mappingCone
open CategoryTheory Limits
variable {C D : Type*} [Category C] [Category D] [Preadditive C] [Preadditive D]
open HomologicalComplex
variable {ι : Type*} [AddRightCancelSemigroup ι] [One ι]
{F G : CochainComplex C ι} (φ : F ⟶ G)
variable {F G : CochainComplex C ℤ} (φ : F ⟶ G)
variable [HasHomotopyCofiber φ]
variable [HasHomotopyCofiber φ]
open HomComplex
theorem theorem_34562 :
(Cochain.ofHom (inr φ)).comp (snd φ) (zero_add 0) = Cochain.ofHom (𝟙 G) := by
aesop_cat
|
import Mathlib.Algebra.Homology.HomotopyCategory.HomComplex
import Mathlib.Algebra.Homology.HomotopyCofiber
import Mathlib.Algebra.Homology.HomotopyCategory.MappingCone
open CochainComplex
open mappingCone
open CategoryTheory Limits
variable {C D : Type*} [Category C] [Category D] [Preadditive C] [Preadditive D]
open HomologicalComplex
variable {ι : Type*} [AddRightCancelSemigroup ι] [One ι]
{F G : CochainComplex C ι} (φ : F ⟶ G)
variable {F G : CochainComplex C ℤ} (φ : F ⟶ G)
variable [HasHomotopyCofiber φ]
variable [HasHomotopyCofiber φ]
open HomComplex
theorem theorem_34562 :
(Cochain.ofHom (inr φ)).comp (snd φ) (zero_add 0) = Cochain.ofHom (𝟙 G) := by
simp [inr_comp_snd]
| null |
abae78748898619ed0b9b4f74fba7934f4a3bbda5977f912a0f7f07d4fd55ec3
| null | null | null | null | null | null | 16
| 8
|
unknown identifier 'inr_comp_snd'
|
simp [inr_comp_snd]
|
C : Type u_1 inst✝³ : Category.{u_4, u_1} C inst✝² : Preadditive C F G : CochainComplex C ℤ φ : F ⟶ G inst✝¹ inst✝ : HasHomotopyCofiber φ ⊢ (Cochain.ofHom (inr φ)).comp (snd φ) ⋯ = Cochain.ofHom (𝟙 G)
|
The proof fails because it references an unknown lemma 'inr_comp_snd', which doesn't exist in the current context or imported modules.
|
Use a more general automation tactic like aesop_cat that can find or construct the required proof.
|
herald
|
lme
|
train
|
TypeVec.diag_sub_val.lean
|
import Mathlib.Data.Fin.Fin2
import Mathlib.Logic.Function.Basic
import Mathlib.Tactic.Common
import Mathlib.Data.TypeVec
open TypeVec
variable {n : ℕ}
open MvFunctor
open Nat
open Function (uncurry)
variable {α β γ : TypeVec.{u} n}
variable (p : α ⟹ «repeat» n Prop) (r : α ⊗ α ⟹ «repeat» n Prop)
variable (p : α ⟹ «repeat» n Prop) (r : α ⊗ α ⟹ «repeat» n Prop)
theorem theorem_1976 {n} {α : TypeVec.{u} n} : subtypeVal (repeatEq α) ⊚ diagSub = prod.diag := by
ext i x
induction' i with _ _ _ i_ih
· simp only [comp, subtypeVal, repeatEq.eq_2, diagSub, prod.diag]
apply @i_ih (drop α)
|
import Mathlib.Data.Fin.Fin2
import Mathlib.Logic.Function.Basic
import Mathlib.Tactic.Common
import Mathlib.Data.TypeVec
open TypeVec
variable {n : ℕ}
open MvFunctor
open Nat
open Function (uncurry)
variable {α β γ : TypeVec.{u} n}
variable (p : α ⟹ «repeat» n Prop) (r : α ⊗ α ⟹ «repeat» n Prop)
variable (p : α ⟹ «repeat» n Prop) (r : α ⊗ α ⟹ «repeat» n Prop)
theorem theorem_1976 {n} {α : TypeVec.{u} n} : subtypeVal (repeatEq α) ⊚ diagSub = prod.diag := by
ext i x
induction i with
· simp only [comp, subtypeVal, repeatEq.eq_2, diagSub, prod.diag]
apply @i_ih (drop α)
| null |
ee5a833e8b190bb37706dee155753a04fc383f05fcc1748aab01d16b692b0158
| null | null | null | null | null | null | 13
| 2
|
Alternative 'fz' has not been provided
|
induction i with
|
case a.h n : ℕ α : TypeVec.{u} n i : Fin2 n x : α i ⊢ (subtypeVal α.repeatEq ⊚ diagSub) i x = prod.diag i x
|
The proof fails because the induction tactic is incorrectly used without specifying the base case pattern for Fin2 (Fin2.zero vs Fin2.succ).
|
Use induction' instead of induction to properly handle Fin2 cases with explicit pattern matching.
|
herald
|
lme
|
train
|
Fin.init_snoc.lean
|
import Mathlib.Data.Fin.Basic
import Mathlib.Data.Nat.Find
import Batteries.Data.Fin.Lemmas
import Mathlib.Data.Fin.Tuple.Basic
open Fin
variable {m n : ℕ}
open Function
variable {α : Fin (n + 1) → Type u} (x : α 0) (q : ∀ i, α i) (p : ∀ i : Fin n, α i.succ) (i : Fin n)
(y : α i.succ) (z : α 0)
variable {α : Fin (n + 1) → Type u} (x : α (last n)) (q : ∀ i, α i)
(p : ∀ i : Fin n, α (castSucc i)) (i : Fin n) (y : α (castSucc i)) (z : α (last n))
theorem theorem_17580 : init (snoc p x) = p := by
ext i
simp only [init, snoc, coe_castSucc, is_lt, cast_eq, dite_true]
convert cast_eq rfl (p i)
|
import Mathlib.Data.Fin.Basic
import Mathlib.Data.Nat.Find
import Batteries.Data.Fin.Lemmas
import Mathlib.Data.Fin.Tuple.Basic
open Fin
variable {m n : ℕ}
open Function
variable {α : Fin (n + 1) → Type u} (x : α 0) (q : ∀ i, α i) (p : ∀ i : Fin n, α i.succ) (i : Fin n)
(y : α i.succ) (z : α 0)
variable {α : Fin (n + 1) → Type u} (x : α (last n)) (q : ∀ i, α i)
(p : ∀ i : Fin n, α (castSucc i)) (i : Fin n) (y : α (castSucc i)) (z : α (last n))
theorem theorem_17580 : init (snoc p x) = p := by
ext i
dsimp [init]
convert cast_eq rfl (p i)
| null |
e8608406393bba0ee2797209bfef834e455ca04c7ad97f2038a2d32690e625fc
| null | null | null | null | null | null | 10
| 47
|
unsolved goals
case h.e'_2
n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
p : (i : Fin n) → α i.castSucc
i : Fin n
⊢ snoc p x i.castSucc = cast ⋯ (p i)
|
theorem theorem_17580 : init (snoc p x) = p := by
|
n : ℕ α : Fin (n + 1) → Type u x : α (last n) p : (i : Fin n) → α i.castSucc ⊢ init (snoc p x) = p
|
The proof fails because the `convert` tactic doesn't fully simplify the `snoc` expression applied to `i.castSucc`, leaving an unsolved goal about the equality of terms.
|
Add more simplification lemmas before the `convert` step to properly reduce the `snoc` application.
|
herald
|
lme
|
train
|
nhdsSet_eq_principal_iff.lean
|
import Mathlib.Topology.Basic
import Mathlib.Topology.NhdsSet
open Set Filter Topology
variable {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] {f : Filter X}
{s t s₁ s₂ t₁ t₂ : Set X} {x : X}
theorem theorem_18985 : 𝓝ˢ s = 𝓟 s ↔ IsOpen s := by
rw [← principal_le_nhdsSet.le_iff_eq, le_principal_iff, mem_nhdsSet_iff_forall,
isOpen_iff_mem_nhds]
|
import Mathlib.Topology.Basic
import Mathlib.Topology.NhdsSet
open Set Filter Topology
variable {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] {f : Filter X}
{s t s₁ s₂ t₁ t₂ : Set X} {x : X}
theorem theorem_18985 : 𝓝ˢ s = 𝓟 s ↔ IsOpen s := by
constructor
isOpen_iff_mem_nhds]
| null |
5e34d46a413031b2f70a184a29aa6cc2568b2438eedd9d021c3a4c603c4d28ac
| null | null | null | null | null | null | 7
| 49
|
unsolved goals
case mp
X : Type u_1
inst✝ : TopologicalSpace X
s : Set X
⊢ 𝓝ˢ s = 𝓟 s → IsOpen s
case mpr
X : Type u_1
inst✝ : TopologicalSpace X
s : Set X
⊢ IsOpen s → 𝓝ˢ s = 𝓟 s
|
theorem theorem_18985 : 𝓝ˢ s = 𝓟 s ↔ IsOpen s := by
|
X : Type u_1 inst✝ : TopologicalSpace X s : Set X ⊢ 𝓝ˢ s = 𝓟 s ↔ IsOpen s
|
The proof fails because it only attempts to use one tactic `isOpen_iff_mem_nhds` which isn't sufficient to prove the bi-implication. The constructor tactic splits the goal into two directions (mp and mpr), but neither subgoal is addressed.
|
Use rewrite tactics to transform both sides of the bi-implication using relevant lemmas about neighborhoods and principal filters.
|
herald
|
lme
|
train
|
ProbabilityTheory.Kernel.sum_fintype.lean
|
import Mathlib.MeasureTheory.Integral.Bochner
import Mathlib.MeasureTheory.Measure.GiryMonad
import Mathlib.Probability.Kernel.Basic
open ProbabilityTheory
open Kernel
open MeasureTheory
open scoped MeasureTheory ENNReal NNReal
variable {α β ι : Type*} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
variable {κ : Kernel α β}
theorem theorem_25974 [Fintype ι] (κ : ι → Kernel α β) : Kernel.sum κ = ∑ i, κ i := by
ext a s hs
simp only [sum_apply' κ a hs, finset_sum_apply' _ κ a s, tsum_fintype]
|
import Mathlib.MeasureTheory.Integral.Bochner
import Mathlib.MeasureTheory.Measure.GiryMonad
import Mathlib.Probability.Kernel.Basic
open ProbabilityTheory
open Kernel
open MeasureTheory
open scoped MeasureTheory ENNReal NNReal
variable {α β ι : Type*} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
variable {κ : Kernel α β}
theorem theorem_25974 [Fintype ι] (κ : ι → Kernel α β) : Kernel.sum κ = ∑ i, κ i := by
ext a s hs
rfl
| null |
8e3746e6213f7acf7dddc2d4897c09a131858fb79a044020350d07941ba3df0d
| null | null | null | null | null | null | 11
| 2
|
tactic 'rfl' failed, the left-hand side
((Kernel.sum κ) a) s
is not definitionally equal to the right-hand side
((∑ i, κ i) a) s
case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝ : Fintype ι
κ : ι → Kernel α β
a : α
s : Set β
hs : MeasurableSet s
⊢ ((Kernel.sum κ) a) s = ((∑ i, κ i) a) s
|
rfl
|
case h.h α : Type u_1 β : Type u_2 ι : Type u_3 mα : MeasurableSpace α mβ : MeasurableSpace β inst✝ : Fintype ι κ : ι → Kernel α β a : α s : Set β hs : MeasurableSet s ⊢ ((Kernel.sum κ) a) s = ((∑ i, κ i) a) s
|
The proof fails because `rfl` can only prove equalities that are definitionally true, but the expressions `((Kernel.sum κ) a) s` and `((∑ i, κ i) a) s` are not definitionally equal - they require unfolding definitions and applying theorems about kernel sums.
|
Use simplification lemmas like `sum_apply'` and `finset_sum_apply'` to rewrite both sides into equivalent forms before applying `rfl`.
|
herald
|
lme
|
train
|
Filter.EventuallyLE.cardinal_bInter.lean
|
import Mathlib.Order.Filter.Basic
import Mathlib.Order.Filter.CountableInter
import Mathlib.SetTheory.Cardinal.Ordinal
import Mathlib.SetTheory.Cardinal.Cofinality
import Mathlib.Order.Filter.CardinalInter
open Filter
open EventuallyLE
open Set Filter Cardinal
variable {ι : Type u} {α β : Type u} {c : Cardinal.{u}}
variable {l : Filter α}
variable [CardinalInterFilter l c]
theorem theorem_22050 {S : Set ι} (hS : #S < c)
{s t : ∀ i ∈ S, Set α} (h : ∀ i hi, s i hi ≤ᶠ[l] t i hi) :
⋂ i ∈ S, s i ‹_› ≤ᶠ[l] ⋂ i ∈ S, t i ‹_› := by
simp only [biInter_eq_iInter]
exact EventuallyLE.cardinal_iInter hS fun i => h i i.2
|
import Mathlib.Order.Filter.Basic
import Mathlib.Order.Filter.CountableInter
import Mathlib.SetTheory.Cardinal.Ordinal
import Mathlib.SetTheory.Cardinal.Cofinality
import Mathlib.Order.Filter.CardinalInter
open Filter
open EventuallyLE
open Set Filter Cardinal
variable {ι : Type u} {α β : Type u} {c : Cardinal.{u}}
variable {l : Filter α}
variable [CardinalInterFilter l c]
theorem theorem_22050 {S : Set ι} (hS : #S < c)
{s t : ∀ i ∈ S, Set α} (h : ∀ i hi, s i hi ≤ᶠ[l] t i hi) :
⋂ i ∈ S, s i ‹_› ≤ᶠ[l] ⋂ i ∈ S, t i ‹_› := by
simp only [biInter_eq_iInter]
exact CardinalInterFilter.eventually_iInter hS h
| null |
be41a2ff636fcc372ca303236623d436b5df6837ec5943569b945d8df7e245f3
| null | null | null | null | null | null | 13
| 8
|
unknown constant 'CardinalInterFilter.eventually_iInter'
|
exact CardinalInterFilter.eventually_iInter hS h
|
ι α : Type u c : Cardinal.{u} l : Filter α inst✝ : CardinalInterFilter l c S : Set ι hS : #↑S < c s t : (i : ι) → i ∈ S → Set α h : ∀ (i : ι) (hi : i ∈ S), s i hi ≤ᶠ[l] t i hi ⊢ ⋂ x, s ↑x ⋯ ≤ᶠ[l] ⋂ x, t ↑x ⋯
|
The proof fails because it references an unknown constant 'CardinalInterFilter.eventually_iInter', which doesn't exist in the available imports.
|
Use 'EventuallyLE.cardinal_iInter' instead, which is the correct function for this operation.
|
herald
|
lme
|
train
|
Pretrivialization.coe_linearMapAt_of_mem.lean
|
import Mathlib.Analysis.Normed.Operator.BoundedLinearMaps
import Mathlib.Topology.FiberBundle.Basic
import Mathlib.Topology.VectorBundle.Basic
open Pretrivialization
open Bundle Set
open scoped Topology
variable (R : Type*) {B : Type*} (F : Type*) (E : B → Type*)
variable {F E}
variable [Semiring R] [TopologicalSpace F] [TopologicalSpace B]
variable [Semiring R] [TopologicalSpace F] [TopologicalSpace B]
variable (e : Pretrivialization F (π F E)) {x : TotalSpace F E} {b : B} {y : E b}
variable [AddCommMonoid F] [Module R F] [∀ x, AddCommMonoid (E x)] [∀ x, Module R (E x)]
open Classical in
variable {R}
open Classical in
theorem theorem_15623 (e : Pretrivialization F (π F E)) [e.IsLinear R] {b : B}
(hb : b ∈ e.baseSet) : ⇑(e.linearMapAt R b) = fun y => (e ⟨b, y⟩).2 := by
simp_rw [coe_linearMapAt, if_pos hb]
|
import Mathlib.Analysis.Normed.Operator.BoundedLinearMaps
import Mathlib.Topology.FiberBundle.Basic
import Mathlib.Topology.VectorBundle.Basic
open Pretrivialization
open Bundle Set
open scoped Topology
variable (R : Type*) {B : Type*} (F : Type*) (E : B → Type*)
variable {F E}
variable [Semiring R] [TopologicalSpace F] [TopologicalSpace B]
variable [Semiring R] [TopologicalSpace F] [TopologicalSpace B]
variable (e : Pretrivialization F (π F E)) {x : TotalSpace F E} {b : B} {y : E b}
variable [AddCommMonoid F] [Module R F] [∀ x, AddCommMonoid (E x)] [∀ x, Module R (E x)]
open Classical in
variable {R}
open Classical in
theorem theorem_15623 (e : Pretrivialization F (π F E)) [e.IsLinear R] {b : B}
(hb : b ∈ e.baseSet) : ⇑(e.linearMapAt R b) = fun y => (e ⟨b, y⟩).2 := by
simp_rw [e.coe_linearMapAt, dif_pos hb]
| null |
0f88d0c8e0e7784225ade9af9d296896083e12934fc55b0810faaa16197b74d8
| null | null | null | null | null | null | 17
| 30
|
simp made no progress
|
simp_rw [e.coe_linearMapAt, dif_pos hb]
|
R : Type u_1 B : Type u_2 F : Type u_3 E : B → Type u_4 inst✝¹⁰ : Semiring R inst✝⁹ : TopologicalSpace F inst✝⁸ : TopologicalSpace B inst✝⁷ : Semiring R inst✝⁶ : TopologicalSpace F inst✝⁵ : TopologicalSpace B inst✝⁴ : AddCommMonoid F inst✝³ : Module R F inst✝² : (x : B) → AddCommMonoid (E x) inst✝¹ : (x : B) → Module R (E x) e : Pretrivialization F TotalSpace.proj inst✝ : Pretrivialization.IsLinear R e b : B hb : b ∈ e.baseSet ⊢ (fun y => if b ∈ e.baseSet then (↑e { proj := b, snd := y }).2 else 0) = fun y => (↑e { proj := b, snd := y }).2
|
The proof fails because `simp_rw` with `dif_pos hb` doesn't simplify the goal since the condition `b ∈ e.baseSet` appears in a different form (as an `if` expression rather than a `dite`).
|
Use `if_pos hb` instead of `dif_pos hb` to match the `if` expression in the goal.
|
herald
|
lme
|
train
|
Surreal.Multiplication.P4_neg_left.lean
|
import Mathlib.Logic.Hydra
import Mathlib.SetTheory.Surreal.Basic
import Mathlib.SetTheory.Surreal.Multiplication
open Surreal
open Multiplication
open SetTheory Game PGame WellFounded
variable {x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame.{u}}
theorem theorem_29512 : P4 x₁ x₂ y ↔ P4 (-x₂) (-x₁) y := by
simp_rw [P4, PGame.neg_lt_neg_iff, moveLeft_neg', ← P3_neg]
|
import Mathlib.Logic.Hydra
import Mathlib.SetTheory.Surreal.Basic
import Mathlib.SetTheory.Surreal.Multiplication
open Surreal
open Multiplication
open SetTheory Game PGame WellFounded
variable {x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame.{u}}
theorem theorem_29512 : P4 x₁ x₂ y ↔ P4 (-x₂) (-x₁) y := by
constructor <;> intro h <;> simpa using h.neg
| null |
48db926d38f8433c6f2436dfb8a90a2d2b6f69d6a581fe06864ac13babcacbe2
| null | null | null | null | null | null | 8
| 42
|
Invalid field `neg`: The environment does not contain `Surreal.Multiplication.P4.neg`
h
has type
P4 x₁ x₂ y
|
constructor <;> intro h <;> simpa using h.neg
|
case mpr x₁ x₂ y : PGame h : P4 (-x₂) (-x₁) y ⊢ P4 x₁ x₂ y
|
The proof fails because it incorrectly assumes P4 has a 'neg' field, but this field doesn't exist in the current environment.
|
Use the correct lemmas about P4 properties and negation instead of the non-existent neg field.
|
herald
|
lme
|
train
|
Real.four_mul_arctan_inv_5_sub_arctan_inv_239.lean
|
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan
open Real
open Set Filter
open scoped Topology Real
theorem theorem_27001 : 4 * arctan 5⁻¹ - arctan 239⁻¹ = π / 4 := by
rw [show 4 * arctan _ = 2 * (2 * _) by ring, two_mul_arctan, two_mul_arctan, ← arctan_one,
sub_eq_iff_eq_add, arctan_add] <;> norm_num
|
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan
open Real
open Set Filter
open scoped Topology Real
theorem theorem_27001 : 4 * arctan 5⁻¹ - arctan 239⁻¹ = π / 4 := by
calc 4 * arctan 5⁻¹ - arctan 239⁻¹ = arctan 1 := by
sub_eq_iff_eq_add, arctan_add] <;> norm_num
| null |
b82cbfb6583e6138c372379de9f55e3dad066648dee862107651ea9a3878eb52
| null | null | null | null | null | null | 6
| 65
|
unsolved goals
case calc.step
⊢ arctan 1 = π / 4
|
theorem theorem_27001 : 4 * arctan 5⁻¹ - arctan 239⁻¹ = π / 4 := by
|
⊢ 4 * arctan 5⁻¹ - arctan 239⁻¹ = π / 4
|
The proof fails because it attempts to use `sub_eq_iff_eq_add` and `arctan_add` directly without first breaking down the 4*arctan term using properties of arctangent.
|
First apply angle doubling formulas to break down the 4*arctan term before using arctan addition identities.
|
herald
|
lme
|
train
|
DomMulAct.stabilizer_card.lean
|
import Mathlib.Algebra.Group.Subgroup.Basic
import Mathlib.GroupTheory.GroupAction.DomAct.Basic
import Mathlib.GroupTheory.GroupAction.Basic
import Mathlib.Data.Fintype.Basic
import Mathlib.Data.Fintype.Perm
import Mathlib.SetTheory.Cardinal.Finite
import Mathlib.GroupTheory.Perm.DomMulAct
open DomMulAct
variable {α ι : Type*} {f : α → ι}
open Equiv MulAction
variable (f)
variable {f}
variable [Fintype α] [Fintype ι] [DecidableEq α] [DecidableEq ι]
open Nat
variable (f)
theorem theorem_20791 :
Fintype.card {g : Perm α // f ∘ g = f} = ∏ i, (Fintype.card {a // f a = i})! := by
-- rewriting via Nat.card because Fintype instance is not found
rw [← Nat.card_eq_fintype_card, Nat.card_congr (subtypeEquiv mk fun _ ↦ ?_),
Nat.card_congr MulOpposite.opEquiv,
Nat.card_congr (DomMulAct.stabilizerMulEquiv f).toEquiv, Nat.card_pi]
· exact Finset.prod_congr rfl fun i _ ↦ by rw [Nat.card_eq_fintype_card, Fintype.card_perm]
· rfl
|
import Mathlib.Algebra.Group.Subgroup.Basic
import Mathlib.GroupTheory.GroupAction.DomAct.Basic
import Mathlib.GroupTheory.GroupAction.Basic
import Mathlib.Data.Fintype.Basic
import Mathlib.Data.Fintype.Perm
import Mathlib.SetTheory.Cardinal.Finite
import Mathlib.GroupTheory.Perm.DomMulAct
open DomMulAct
variable {α ι : Type*} {f : α → ι}
open Equiv MulAction
variable (f)
variable {f}
variable [Fintype α] [Fintype ι] [DecidableEq α] [DecidableEq ι]
open Nat
variable (f)
theorem theorem_20791 :
Fintype.card {g : Perm α // f ∘ g = f} = ∏ i, (Fintype.card {a // f a = i})! := by
-- rewriting via Nat.card because Fintype instance is not found
rw [← Nat.card_eq_fintype_card, Nat.card_congr (subtypeEquiv mk fun _ ↦ ?_),
Nat.card_congr MulOpposite.opEquiv,
Nat.card_congr (Equiv.piCongrRight fun i => (Perm.subtypePerm (fun a => f a = i)).symm)
· exact Finset.prod_congr rfl fun i _ ↦ by rw [Nat.card_eq_fintype_card, Fintype.card_perm]
· rfl
| null |
f710ad0dbd89c6e318a259019a03a42a565c31191f32c381e9a0d4a7a9c09565
| null | null | null | null | null | null | 12
| 84
|
unsolved goals
α : Type u_1
ι : Type u_2
f : α → ι
inst✝³ : Fintype α
inst✝² : Fintype ι
inst✝¹ : DecidableEq α
inst✝ : DecidableEq ι
⊢ Nat.card { b // ?m.2003 b }ᵐᵒᵖ = ∏ i, (Fintype.card { a // f a = i })!
α : Type u_1
ι : Type u_2
f : α → ι
inst✝³ : Fintype α
inst✝² : Fintype ι
inst✝¹ : DecidableEq α
inst✝ : DecidableEq ι
⊢ (Perm α)ᵈᵐᵃ → Prop
α : Type u_1
ι : Type u_2
f : α → ι
inst✝³ : Fintype α
inst✝² : Fintype ι
inst✝¹ : DecidableEq α
inst✝ : DecidableEq ι
⊢ (Perm α)ᵈᵐᵃ → Prop
α : Type u_1
ι : Type u_2
f : α → ι
inst✝³ : Fintype α
inst✝² : Fintype ι
inst✝¹ : DecidableEq α
inst✝ : DecidableEq ι
x✝ : Perm α
⊢ f ∘ ⇑x✝ = f ↔ ?m.2003 (DomMulAct.mk x✝)
|
Fintype.card {g : Perm α // f ∘ g = f} = ∏ i, (Fintype.card {a // f a = i})! := by
|
α : Type u_1 ι : Type u_2 f : α → ι inst✝³ : Fintype α inst✝² : Fintype ι inst✝¹ : DecidableEq α inst✝ : DecidableEq ι ⊢ Fintype.card { g // f ∘ ⇑g = f } = ∏ i, (Fintype.card { a // f a = i })!
|
The proof fails because the rewritten goal leaves unresolved meta-variables (?m.2003) and doesn't properly connect to the required proposition about permutations preserving fibers of f. The equivalence used (Equiv.piCongrRight) doesn't match the needed stabilization property.
|
Replace the incorrect equivalence with the proper stabilizer equivalence (DomMulAct.stabilizerMulEquiv) that handles permutations preserving f's fibers.
|
herald
|
lme
|
train
|
Doset.mk_eq_of_doset_eq.lean
|
import Mathlib.Algebra.Group.Subgroup.Pointwise
import Mathlib.GroupTheory.Coset.Basic
import Mathlib.GroupTheory.DoubleCoset
open Doset
variable {G : Type*} [Group G] {α : Type*} [Mul α] (J : Subgroup G) (g : G)
open MulOpposite
open scoped Pointwise
theorem theorem_22642 {H K : Subgroup G} {a b : G} (h : doset a H K = doset b H K) :
mk H K a = mk H K b := by
rw [eq]
exact mem_doset.mp (h.symm ▸ mem_doset_self H K b)
|
import Mathlib.Algebra.Group.Subgroup.Pointwise
import Mathlib.GroupTheory.Coset.Basic
import Mathlib.GroupTheory.DoubleCoset
open Doset
variable {G : Type*} [Group G] {α : Type*} [Mul α] (J : Subgroup G) (g : G)
open MulOpposite
open scoped Pointwise
theorem theorem_22642 {H K : Subgroup G} {a b : G} (h : doset a H K = doset b H K) :
mk H K a = mk H K b := by
rw [eq]
exact h
| null |
28827ad2ba0a092cf7b738e3af3e6b271a82947d62bed15d8a8f38fa84b20071
| null | null | null | null | null | null | 10
| 2
|
type mismatch
h
has type
doset a ↑H ↑K = doset b ↑H ↑K : Prop
but is expected to have type
∃ h ∈ H, ∃ k ∈ K, b = h * a * k : Prop
|
exact h
|
G : Type u_1 inst✝ : Group G H K : Subgroup G a b : G h : doset a ↑H ↑K = doset b ↑H ↑K ⊢ ∃ h ∈ H, ∃ k ∈ K, b = h * a * k
|
The proof fails because `h` is an equality between double cosets, but `eq` expects an existential statement about group elements relating `a` and `b`.
|
Convert the double coset equality `h` into the required existential statement using `mem_doset.mp` and properties of double cosets.
|
herald
|
lme
|
train
|
UniformSpace.mem_comp_comp.lean
|
import Mathlib.Order.Filter.SmallSets
import Mathlib.Tactic.Monotonicity
import Mathlib.Topology.Compactness.Compact
import Mathlib.Topology.NhdsSet
import Mathlib.Algebra.Group.Defs
import Mathlib.Topology.UniformSpace.Basic
open UniformSpace
open Set Filter Topology
variable {α : Type ua} {β : Type ub} {γ : Type uc} {δ : Type ud} {ι : Sort*}
open Uniformity
variable [UniformSpace α]
open UniformSpace (ball)
theorem theorem_32181 {V W M : Set (β × β)} (hW' : SymmetricRel W) {p : β × β} :
p ∈ V ○ M ○ W ↔ (ball p.1 V ×ˢ ball p.2 W ∩ M).Nonempty := by
cases' p with x y
constructor
· rintro ⟨z, ⟨w, hpw, hwz⟩, hzy⟩
exact ⟨(w, z), ⟨hpw, by rwa [mem_ball_symmetry hW']⟩, hwz⟩
· rintro ⟨⟨w, z⟩, ⟨w_in, z_in⟩, hwz⟩
rw [mem_ball_symmetry hW'] at z_in
exact ⟨z, ⟨w, w_in, hwz⟩, z_in⟩
|
import Mathlib.Order.Filter.SmallSets
import Mathlib.Tactic.Monotonicity
import Mathlib.Topology.Compactness.Compact
import Mathlib.Topology.NhdsSet
import Mathlib.Algebra.Group.Defs
import Mathlib.Topology.UniformSpace.Basic
open UniformSpace
open Set Filter Topology
variable {α : Type ua} {β : Type ub} {γ : Type uc} {δ : Type ud} {ι : Sort*}
open Uniformity
variable [UniformSpace α]
open UniformSpace (ball)
theorem theorem_32181 {V W M : Set (β × β)} (hW' : SymmetricRel W) {p : β × β} :
p ∈ V ○ M ○ W ↔ (ball p.1 V ×ˢ ball p.2 W ∩ M).Nonempty := by
simp_rw [Set.mem_compRel]
constructor
· rintro ⟨z, ⟨w, hpw, hwz⟩, hzy⟩
exact ⟨(w, z), ⟨hpw, by rwa [mem_ball_symmetry hW']⟩, hwz⟩
· rintro ⟨⟨w, z⟩, ⟨w_in, z_in⟩, hwz⟩
rw [mem_ball_symmetry hW'] at z_in
exact ⟨z, ⟨w, w_in, hwz⟩, z_in⟩
| null |
c3c49c34040e758a5f2ff01037038c1517785471aaae937e14c92cee286ce380
| null | null | null | null | null | null | 11
| 11
|
unknown constant 'Set.mem_compRel'
|
simp_rw [Set.mem_compRel]
|
β : Type ub V W M : Set (β × β) hW' : SymmetricRel W p : β × β ⊢ p ∈ V ○ M ○ W ↔ (ball p.1 V ×ˢ ball p.2 W ∩ M).Nonempty
|
The proof fails because it references 'Set.mem_compRel' which is not a known theorem/definition in the current context, suggesting missing imports.
|
Add the required imports that contain the definition of 'Set.mem_compRel' to make the theorem available.
|
herald
|
lme
|
train
|
MvPolynomial.bind₂_monomial.lean
|
import Mathlib.Algebra.MvPolynomial.Rename
import Mathlib.Algebra.MvPolynomial.Variables
import Mathlib.Algebra.MvPolynomial.Monad
open MvPolynomial
open Finsupp
variable {σ : Type*} {τ : Type*}
variable {R S T : Type*} [CommSemiring R] [CommSemiring S] [CommSemiring T]
variable {R S T : Type*} [CommSemiring R] [CommSemiring S] [CommSemiring T]
variable (σ R)
variable (f : σ → MvPolynomial τ R)
theorem theorem_22926 (f : R →+* MvPolynomial σ S) (d : σ →₀ ℕ) (r : R) :
bind₂ f (monomial d r) = f r * monomial d 1 := by
simp only [monomial_eq, RingHom.map_mul, bind₂_C_right, Finsupp.prod, map_prod,
map_pow, bind₂_X_right, C_1, one_mul]
|
import Mathlib.Algebra.MvPolynomial.Rename
import Mathlib.Algebra.MvPolynomial.Variables
import Mathlib.Algebra.MvPolynomial.Monad
open MvPolynomial
open Finsupp
variable {σ : Type*} {τ : Type*}
variable {R S T : Type*} [CommSemiring R] [CommSemiring S] [CommSemiring T]
variable {R S T : Type*} [CommSemiring R] [CommSemiring S] [CommSemiring T]
variable (σ R)
variable (f : σ → MvPolynomial τ R)
theorem theorem_22926 (f : R →+* MvPolynomial σ S) (d : σ →₀ ℕ) (r : R) :
bind₂ f (monomial d r) = f r * monomial d 1 := by
rw [bind₂_monomial, map_pow, bind₂_X_right, C_1, one_mul]
map_pow, bind₂_X_right, C_1, one_mul]
| null |
44b8fc40572cc39b955fb70141c9be77068b71a1ecd56a27c5a9301f2162a19a
| null | null | null | null | null | null | 12
| 22
|
tactic 'rewrite' failed, did not find instance of the pattern in the target expression
?f (?a ^ ?n)
σ : Type u_1
R : Type u_6
S : Type u_7
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* MvPolynomial σ S
d : σ →₀ ℕ
r : R
⊢ f r * (monomial d) 1 = f r * (monomial d) 1
|
rw [bind₂_monomial, map_pow, bind₂_X_right, C_1, one_mul]
|
σ : Type u_1 R : Type u_6 S : Type u_7 inst✝¹ : CommSemiring R inst✝ : CommSemiring S f : R →+* MvPolynomial σ S d : σ →₀ ℕ r : R ⊢ f r * (monomial d) 1 = f r * (monomial d) 1
|
The proof fails because the rewrite tactic `map_pow` is looking for a power operation in the target expression, but the target is already in the desired form (an equality where both sides are identical). The proof is stuck in a loop trying to apply the same rewrite rules repeatedly.
|
Replace the rewrite sequence with a single simplification step using `simp` with the relevant lemmas.
|
herald
|
lme
|
train
|
Set.isWF_univ_iff.lean
|
import Mathlib.Data.Prod.Lex
import Mathlib.Data.Sigma.Lex
import Mathlib.Order.Antichain
import Mathlib.Order.OrderIsoNat
import Mathlib.Order.WellFounded
import Mathlib.Tactic.TFAE
import Mathlib.Order.WellFoundedSet
open Set
variable {ι α β γ : Type*} {π : ι → Type*}
variable {r r' : α → α → Prop}
variable {f : β → α} {s t : Set α} {x y : α}
open Relation
open List in
variable [IsStrictOrder α r] {s t : Set α}
variable [LT α] {s t : Set α}
theorem theorem_8079 : IsWF (univ : Set α) ↔ WellFounded ((· < ·) : α → α → Prop) := by
simp [IsWF, wellFoundedOn_iff]
|
import Mathlib.Data.Prod.Lex
import Mathlib.Data.Sigma.Lex
import Mathlib.Order.Antichain
import Mathlib.Order.OrderIsoNat
import Mathlib.Order.WellFounded
import Mathlib.Tactic.TFAE
import Mathlib.Order.WellFoundedSet
open Set
variable {ι α β γ : Type*} {π : ι → Type*}
variable {r r' : α → α → Prop}
variable {f : β → α} {s t : Set α} {x y : α}
open Relation
open List in
variable [IsStrictOrder α r] {s t : Set α}
variable [LT α] {s t : Set α}
theorem theorem_8079 : IsWF (univ : Set α) ↔ WellFounded ((· < ·) : α → α → Prop) := by
simp [IsWF, wellFounded_iff_has_min]
| null |
cfa820c3cac1630fce34f8f88d69e620b74d4fdae12c150c9d6c4a68d215821f
| null | null | null | null | null | null | 12
| 14
|
unknown identifier 'wellFounded_iff_has_min'
|
simp [IsWF, wellFounded_iff_has_min]
|
α : Type u_2 inst✝ : LT α ⊢ univ.IsWF ↔ WellFounded fun x1 x2 => x1 < x2
|
The proof fails because it references an unknown identifier 'wellFounded_iff_has_min', which is not imported or defined in the current context.
|
Use 'wellFoundedOn_iff' instead of 'wellFounded_iff_has_min' as it's the correct lemma available in the context.
|
herald
|
lme
|
train
|
Coheyting.boundary_le_boundary_sup_sup_boundary_inf_right.lean
|
import Mathlib.Order.BooleanAlgebra
import Mathlib.Tactic.Common
import Mathlib.Order.Heyting.Boundary
open Coheyting
variable {α : Type*}
variable [CoheytingAlgebra α] {a b : α}
open Heyting
theorem theorem_1767 : ∂ b ≤ ∂ (a ⊔ b) ⊔ ∂ (a ⊓ b) := by
rw [sup_comm a, inf_comm]
exact boundary_le_boundary_sup_sup_boundary_inf_left
|
import Mathlib.Order.BooleanAlgebra
import Mathlib.Tactic.Common
import Mathlib.Order.Heyting.Boundary
open Coheyting
variable {α : Type*}
variable [CoheytingAlgebra α] {a b : α}
open Heyting
theorem theorem_1767 : ∂ b ≤ ∂ (a ⊔ b) ⊔ ∂ (a ⊓ b) := by
exact boundary_le_boundary_sup_sup_boundary_inf_left
exact boundary_le_boundary_sup_sup_boundary_inf_left
| null |
86afda3bdaca4f7fe2a8997d9edc4894df51d54f71d989eba8237beb8fd3b9d4
| null | null | null | null | null | null | 8
| 8
|
typeclass instance problem is stuck, it is often due to metavariables
CoheytingAlgebra ?m.657
|
exact boundary_le_boundary_sup_sup_boundary_inf_left
|
α : Type u_1 inst✝ : CoheytingAlgebra α a b : α ⊢ ∂ b ≤ ∂ (a ⊔ b) ⊔ ∂ (a ⊓ b)
|
The proof fails because it calls the same lemma twice without modifying the goal, and Lean cannot infer the correct typeclass instance due to metavariables in the context.
|
Rewrite the goal using commutative properties of sup and inf operations before applying the lemma to match its expected form.
|
herald
|
lme
|
train
|
Subgroup.eq_top_of_card_eq.lean
|
import Mathlib.Algebra.Group.Subgroup.Basic
import Mathlib.Algebra.Group.Submonoid.Membership
import Mathlib.Data.Finite.Card
import Mathlib.Algebra.Group.Subgroup.Finite
open Subgroup
variable {G : Type*} [Group G]
variable {A : Type*} [AddGroup A]
variable {A : Type*} [AddGroup A]
variable (H K : Subgroup G)
theorem theorem_42795 [Finite H] (h : Nat.card H = Nat.card G) : H = ⊤ := by
have : Finite G := Nat.finite_of_card_ne_zero (h ▸ Nat.card_pos.ne')
exact eq_top_of_le_card _ (Nat.le_of_eq h.symm)
|
import Mathlib.Algebra.Group.Subgroup.Basic
import Mathlib.Algebra.Group.Submonoid.Membership
import Mathlib.Data.Finite.Card
import Mathlib.Algebra.Group.Subgroup.Finite
open Subgroup
variable {G : Type*} [Group G]
variable {A : Type*} [AddGroup A]
variable {A : Type*} [AddGroup A]
variable (H K : Subgroup G)
theorem theorem_42795 [Finite H] (h : Nat.card H = Nat.card G) : H = ⊤ := by
have : Finite G := by rwa [finite_iff_finite_of_card_eq h]
exact eq_top_of_le_card _ (Nat.le_of_eq h.symm)
| null |
45bca2b9c3c264914f4e01ae7185aa63357d8a0d882106050141c052235ef8d5
| null | null | null | null | null | null | 9
| 29
|
unknown identifier 'finite_iff_finite_of_card_eq'
|
have : Finite G := by rwa [finite_iff_finite_of_card_eq h]
|
G : Type u_1 inst✝¹ : Group G H : Subgroup G inst✝ : Finite ↥H h : Nat.card ↥H = Nat.card G ⊢ Finite G
|
The proof fails because it uses an undefined lemma 'finite_iff_finite_of_card_eq', which doesn't exist in the imported libraries.
|
Replace the undefined lemma with a valid proof that derives finiteness from the cardinality equality using Nat.finite_of_card_ne_zero.
|
herald
|
lme
|
train
|
EReal.coe_ennreal_pos.lean
|
import Mathlib.Data.Real.Basic
import Mathlib.Data.ENNReal.Real
import Mathlib.Data.Sign
import Mathlib.Data.Real.EReal
open EReal
open Function ENNReal NNReal Set SignType
theorem theorem_4497 {x : ℝ≥0∞} : (0 : EReal) < x ↔ 0 < x := by
rw [← coe_ennreal_zero, coe_ennreal_lt_coe_ennreal_iff]
|
import Mathlib.Data.Real.Basic
import Mathlib.Data.ENNReal.Real
import Mathlib.Data.Sign
import Mathlib.Data.Real.EReal
open EReal
open Function ENNReal NNReal Set SignType
theorem theorem_4497 {x : ℝ≥0∞} : (0 : EReal) < x ↔ 0 < x := by
exact ENNReal.toEReal_pos
| null |
6f78ca0624932bd581512c5c966ad4e151f21d27c9d7270fc4ed4e8dcac9c358
| null | null | null | null | null | null | 6
| 8
|
unknown constant 'ENNReal.toEReal_pos'
|
exact ENNReal.toEReal_pos
|
x : ℝ≥0∞ ⊢ 0 < ↑x ↔ 0 < x
|
The proof fails because it references an undefined lemma 'ENNReal.toEReal_pos' that doesn't exist in the current context.
|
Use existing lemmas about coercion and comparison between EReal and ENNReal to rewrite the goal.
|
herald
|
lme
|
train
|
Real.rpow_add_natCast'.lean
|
import Mathlib.Analysis.SpecialFunctions.Pow.Complex
import Qq
import Mathlib.Analysis.SpecialFunctions.Pow.Real
open Real
open scoped Classical
open Real ComplexConjugate
open Finset Set
variable {x y z : ℝ}
open Real
variable {w x y z : ℝ}
open Lean Meta Qq
variable {x y z : ℝ} {n : ℕ}
theorem theorem_37365 (hx : 0 ≤ x) (h : y + n ≠ 0) : x ^ (y + n) = x ^ y * x ^ n := by
rw [rpow_add' hx h, rpow_natCast]
|
import Mathlib.Analysis.SpecialFunctions.Pow.Complex
import Qq
import Mathlib.Analysis.SpecialFunctions.Pow.Real
open Real
open scoped Classical
open Real ComplexConjugate
open Finset Set
variable {x y z : ℝ}
open Real
variable {w x y z : ℝ}
open Lean Meta Qq
variable {x y z : ℝ} {n : ℕ}
theorem theorem_37365 (hx : 0 ≤ x) (h : y + n ≠ 0) : x ^ (y + n) = x ^ y * x ^ n := by
exact Real.rpow_add (hx.lt_of_ne (λ hx0 => h (by simp [hx0]))) y (n : ℝ)
| null |
361e415e72669a072867db3265b2a7ab568667c6b88e0667d1eecde296c3065a
| null | null | null | null | null | null | 13
| 48
|
unsolved goals
x y : ℝ
n : ℕ
hx : 0 ≤ x
h : y + ↑n ≠ 0
hx0 : 0 = x
⊢ y + ↑n = x
|
exact Real.rpow_add (hx.lt_of_ne (λ hx0 => h (by simp [hx0]))) y (n : ℝ)
|
x y : ℝ n : ℕ hx : 0 ≤ x h : y + ↑n ≠ 0 hx0 : 0 = x ⊢ y + ↑n = 0
|
The proof fails because the proof attempts to use `lt_of_ne` to show `x > 0` from `x ≤ 0` and `x ≠ 0`, but then introduces a new subgoal to show `y + n = 0` when `x = 0`, which contradicts the hypothesis `h : y + n ≠ 0`.
|
Use `rpow_add'` directly with the existing hypotheses `hx` and `h` instead of trying to prove `x > 0` first.
|
herald
|
lme
|
train
|
Polynomial.trailingDegree_one_le.lean
|
import Mathlib.Algebra.Polynomial.Degree.Definitions
import Mathlib.Data.ENat.Basic
import Mathlib.Data.ENat.Lattice
import Mathlib.Algebra.Polynomial.Degree.TrailingDegree
open Polynomial
open Function Polynomial Finsupp Finset
open scoped Polynomial
variable {R : Type u} {S : Type v} {a b : R} {n m : ℕ}
variable [Semiring R] {p q r : R[X]}
theorem theorem_13816 : (0 : ℕ∞) ≤ trailingDegree (1 : R[X]) := by
rw [← C_1]
exact le_trailingDegree_C
|
import Mathlib.Algebra.Polynomial.Degree.Definitions
import Mathlib.Data.ENat.Basic
import Mathlib.Data.ENat.Lattice
import Mathlib.Algebra.Polynomial.Degree.TrailingDegree
open Polynomial
open Function Polynomial Finsupp Finset
open scoped Polynomial
variable {R : Type u} {S : Type v} {a b : R} {n m : ℕ}
variable [Semiring R] {p q r : R[X]}
theorem theorem_13816 : (0 : ℕ∞) ≤ trailingDegree (1 : R[X]) := by
rw [← C_1]
exact le_trailingDegree_C 1
| null |
9827c4446a43396700b6f7461165e6566c7034ed5d36fe36788550c6e2b46eaa
| null | null | null | null | null | null | 10
| 8
|
typeclass instance problem is stuck, it is often due to metavariables
Semiring ?m.526
|
exact le_trailingDegree_C 1
|
R : Type u inst✝ : Semiring R ⊢ 0 ≤ (C 1).trailingDegree
|
The proof fails because Lean cannot infer the semiring instance for the type involved in the `le_trailingDegree_C` application, as indicated by the metavariable error.
|
Remove the explicit argument `1` from `le_trailingDegree_C` to let Lean infer the instance automatically.
|
herald
|
lme
|
train
|
ZMod.χ₈_nat_mod_eight.lean
|
import Mathlib.Data.Int.Range
import Mathlib.Data.ZMod.Basic
import Mathlib.NumberTheory.MulChar.Basic
import Mathlib.NumberTheory.LegendreSymbol.ZModChar
open ZMod
theorem theorem_31582 (n : ℕ) : χ₈ n = χ₈ (n % 8 : ℕ) := by
rw [← ZMod.natCast_mod n 8]
|
import Mathlib.Data.Int.Range
import Mathlib.Data.ZMod.Basic
import Mathlib.NumberTheory.MulChar.Basic
import Mathlib.NumberTheory.LegendreSymbol.ZModChar
open ZMod
theorem theorem_31582 (n : ℕ) : χ₈ n = χ₈ (n % 8 : ℕ) := by
exact map_mod χ₈ n
| null |
47b15196787b5f95c3203a9eb506ffe6b4b617877cd7db3afc02f7dc8db88904
| null | null | null | null | null | null | 5
| 8
|
unknown identifier 'map_mod'
|
exact map_mod χ₈ n
|
n : ℕ ⊢ χ₈ ↑n = χ₈ ↑(n % 8)
|
The proof fails because it attempts to use an undefined identifier 'map_mod' which doesn't exist in Lean's library or context.
|
Use the correct lemma 'ZMod.natCast_mod' which properly relates natural number casting and modulus in ZMod.
|
herald
|
lme
|
train
|
sphere_prod.lean
|
import Mathlib.Topology.Bornology.Constructions
import Mathlib.Topology.MetricSpace.Pseudo.Defs
import Mathlib.Topology.UniformSpace.UniformEmbedding
import Mathlib.Topology.MetricSpace.Pseudo.Constructions
open Bornology Filter Metric Set
open scoped NNReal Topology
variable {α β : Type*} [PseudoMetricSpace α]
variable [PseudoMetricSpace β]
variable [PseudoMetricSpace β]
theorem theorem_12904 (x : α × β) (r : ℝ) :
sphere x r = sphere x.1 r ×ˢ closedBall x.2 r ∪ closedBall x.1 r ×ˢ sphere x.2 r := by
obtain hr | rfl | hr := lt_trichotomy r 0
· simp [hr]
· cases x
simp_rw [← closedBall_eq_sphere_of_nonpos le_rfl, union_self, closedBall_prod_same]
· ext ⟨x', y'⟩
simp_rw [Set.mem_union, Set.mem_prod, Metric.mem_closedBall, Metric.mem_sphere, Prod.dist_eq,
max_eq_iff]
refine or_congr (and_congr_right ?_) (and_comm.trans (and_congr_left ?_))
all_goals rintro rfl; rfl
|
import Mathlib.Topology.Bornology.Constructions
import Mathlib.Topology.MetricSpace.Pseudo.Defs
import Mathlib.Topology.UniformSpace.UniformEmbedding
import Mathlib.Topology.MetricSpace.Pseudo.Constructions
open Bornology Filter Metric Set
open scoped NNReal Topology
variable {α β : Type*} [PseudoMetricSpace α]
variable [PseudoMetricSpace β]
variable [PseudoMetricSpace β]
theorem theorem_12904 (x : α × β) (r : ℝ) :
sphere x r = sphere x.1 r ×ˢ closedBall x.2 r ∪ closedBall x.1 r ×ˢ sphere x.2 r := by
obtain hr | rfl | hr := lt_trichotomy r 0
· simp [hr]
· cases x
simp_rw [← closedBall_eq_sphere_of_nonpos le_rfl, union_self, closedBall_prod_same]
· ext ⟨x', y'⟩
simp_rw [Set.mem_union, Set.mem_prod, Metric.mem_closedBall, Metric.mem_sphere, Prod.dist_eq,
max_eq_iff]
refine or_congr (and_congr_right ?_) (and_comm.trans (and_congr_left ?_))
fun h => by rw [h]; exact max_eq_left_iff.symm
| null |
963a3afaa0575f34ebe2d2ccd490f376e000cce563a4088ceecd6a17f4bc23a2
| null | null | null | null | null | null | 15
| 2
|
unsolved goals
case inr.inr.h.mk.refine_1
α : Type u_1
β : Type u_2
inst✝² : PseudoMetricSpace α
inst✝¹ inst✝ : PseudoMetricSpace β
x : α × β
r : ℝ
hr : 0 < r
x' : α
y' : β
⊢ dist x' x.1 = r → (dist y' x.2 ≤ dist x' x.1 ↔ dist y' x.2 ≤ r)
case inr.inr.h.mk.refine_2
α : Type u_1
β : Type u_2
inst✝² : PseudoMetricSpace α
inst✝¹ inst✝ : PseudoMetricSpace β
x : α × β
r : ℝ
hr : 0 < r
x' : α
y' : β
⊢ dist y' x.2 = r → (dist x' x.1 ≤ dist y' x.2 ↔ dist x' x.1 ≤ r)
|
· ext ⟨x', y'⟩
|
case inr.inr α : Type u_1 β : Type u_2 inst✝² : PseudoMetricSpace α inst✝¹ inst✝ : PseudoMetricSpace β x : α × β r : ℝ hr : 0 < r ⊢ sphere x r = sphere x.1 r ×ˢ closedBall x.2 r ∪ closedBall x.1 r ×ˢ sphere x.2 r
|
The proof fails because the two goals created by `refine or_congr` remain unsolved - the proof attempts to use a malformed lambda expression that doesn't properly handle the cases for the distance comparisons.
|
Replace the malformed lambda with proper case handling using `rintro rfl` to simplify the distance equalities.
|
herald
|
lme
|
train
|
StructureGroupoid.LocalInvariantProp.liftPropWithinAt_mono.lean
|
import Mathlib.Geometry.Manifold.ChartedSpace
import Mathlib.Geometry.Manifold.LocalInvariantProperties
open StructureGroupoid
open LocalInvariantProp
open Set Filter TopologicalSpace
open scoped Manifold Topology
variable {H M H' M' X : Type*}
variable [TopologicalSpace H] [TopologicalSpace M] [ChartedSpace H M]
variable [TopologicalSpace H'] [TopologicalSpace M'] [ChartedSpace H' M']
variable [TopologicalSpace X]
variable [TopologicalSpace H] [TopologicalSpace M] [ChartedSpace H M]
variable [TopologicalSpace H'] [TopologicalSpace M'] [ChartedSpace H' M']
variable [TopologicalSpace X]
variable [TopologicalSpace H'] [TopologicalSpace M'] [ChartedSpace H' M']
variable [TopologicalSpace X]
variable [TopologicalSpace X]
variable (G : StructureGroupoid H) (G' : StructureGroupoid H')
variable {G G'} {P : (H → H') → Set H → H → Prop} {s t u : Set H} {x : H}
variable (hG : G.LocalInvariantProp G' P)
include hG
variable (hG : G.LocalInvariantProp G' P)
include hG
open ChartedSpace
variable {G : StructureGroupoid H} {G' : StructureGroupoid H'} {e e' : PartialHomeomorph M H}
{f f' : PartialHomeomorph M' H'} {P : (H → H') → Set H → H → Prop} {g g' : M → M'} {s t : Set M}
{x : M} {Q : (H → H) → Set H → H → Prop}
variable (hG : G.LocalInvariantProp G' P)
include hG
theorem theorem_24333 (mono : ∀ ⦃s x t⦄ ⦃f : H → H'⦄, t ⊆ s → P f s x → P f t x)
(h : LiftPropWithinAt P g s x) (hts : t ⊆ s) : LiftPropWithinAt P g t x := by
refine ⟨h.1.mono hts, mono (fun y hy ↦ ?_) h.2⟩
simp only [mfld_simps] at hy
simp only [hy, hts _, mfld_simps]
|
import Mathlib.Geometry.Manifold.ChartedSpace
import Mathlib.Geometry.Manifold.LocalInvariantProperties
open StructureGroupoid
open LocalInvariantProp
open Set Filter TopologicalSpace
open scoped Manifold Topology
variable {H M H' M' X : Type*}
variable [TopologicalSpace H] [TopologicalSpace M] [ChartedSpace H M]
variable [TopologicalSpace H'] [TopologicalSpace M'] [ChartedSpace H' M']
variable [TopologicalSpace X]
variable [TopologicalSpace H] [TopologicalSpace M] [ChartedSpace H M]
variable [TopologicalSpace H'] [TopologicalSpace M'] [ChartedSpace H' M']
variable [TopologicalSpace X]
variable [TopologicalSpace H'] [TopologicalSpace M'] [ChartedSpace H' M']
variable [TopologicalSpace X]
variable [TopologicalSpace X]
variable (G : StructureGroupoid H) (G' : StructureGroupoid H')
variable {G G'} {P : (H → H') → Set H → H → Prop} {s t u : Set H} {x : H}
variable (hG : G.LocalInvariantProp G' P)
include hG
variable (hG : G.LocalInvariantProp G' P)
include hG
open ChartedSpace
variable {G : StructureGroupoid H} {G' : StructureGroupoid H'} {e e' : PartialHomeomorph M H}
{f f' : PartialHomeomorph M' H'} {P : (H → H') → Set H → H → Prop} {g g' : M → M'} {s t : Set M}
{x : M} {Q : (H → H) → Set H → H → Prop}
variable (hG : G.LocalInvariantProp G' P)
include hG
theorem theorem_24333 (mono : ∀ ⦃s x t⦄ ⦃f : H → H'⦄, t ⊆ s → P f s x → P f t x)
(h : LiftPropWithinAt P g s x) (hts : t ⊆ s) : LiftPropWithinAt P g t x := by
have hy := mono hts h.2.1
simp only [mfld_simps] at hy
simp only [hy, hts _, mfld_simps]
| null |
4ade587632f6f530f4e12f1d23df60b3a36e3f0c9ee75e6b856d1eb5cb478d17
| null | null | null | null | null | null | 31
| 18
|
Application type mismatch: In the application
mono hts
the argument
hts
has type
Subset.{u_2} t s : Prop
but is expected to have type
Subset.{u_1} ?m.6991 ?m.6989 : Prop
|
have hy := mono hts h.2.1
|
H : Type u_1 M : Type u_2 H' : Type u_3 M' : Type u_4 inst✝¹⁴ : TopologicalSpace H inst✝¹³ : TopologicalSpace M inst✝¹² : ChartedSpace H M inst✝¹¹ : TopologicalSpace H' inst✝¹⁰ : TopologicalSpace M' inst✝⁹ : ChartedSpace H' M' inst✝⁸ : TopologicalSpace H inst✝⁷ : TopologicalSpace M inst✝⁶ : ChartedSpace H M inst✝⁵ : TopologicalSpace H' inst✝⁴ : TopologicalSpace M' inst✝³ : ChartedSpace H' M' inst✝² : TopologicalSpace H' inst✝¹ : TopologicalSpace M' inst✝ : ChartedSpace H' M' G : StructureGroupoid H G' : StructureGroupoid H' P✝ : (H → H') → Set H → H → Prop hG : G.LocalInvariantProp G' P✝ P : (H → H') → Set H → H → Prop g : M → M' s t : Set M x : M mono : ∀ ⦃s : Set H⦄ ⦃x : H⦄ ⦃t : Set H⦄ ⦃f : H → H'⦄, t ⊆ s → P f s x → P f t x h : LiftPropWithinAt P g s x hts : t ⊆ s ⊢ LiftPropWithinAt P g t x
|
The proof fails because the argument `hts` given to `mono` is about subsets of `M` (`t ⊆ s`), but `mono` expects subsets of `H` (`t ⊆ s` for `H`). There's a type mismatch between sets of the manifold and sets of the model space.
|
Transform the subset condition to work with the model space `H` rather than the manifold `M` by using charting functions.
|
herald
|
lme
|
train
|
Matrix.det_of_card_zero.lean
|
import Mathlib.Algebra.Polynomial.Expand
import Mathlib.Algebra.Polynomial.Laurent
import Mathlib.LinearAlgebra.Matrix.Charpoly.Basic
import Mathlib.LinearAlgebra.Matrix.Reindex
import Mathlib.RingTheory.Polynomial.Nilpotent
import Mathlib.LinearAlgebra.Matrix.Charpoly.Coeff
open Matrix
open Finset Matrix Polynomial
variable {R : Type u} [CommRing R]
variable {n G : Type v} [DecidableEq n] [Fintype n]
variable {α β : Type v} [DecidableEq α]
variable {M : Matrix n n R}
variable {n G : Type v} [DecidableEq n] [Fintype n]
variable {α β : Type v} [DecidableEq α]
variable {M : Matrix n n R}
variable {α β : Type v} [DecidableEq α]
variable {M : Matrix n n R}
variable {M : Matrix n n R}
variable (M)
theorem theorem_31099 (h : Fintype.card n = 0) (M : Matrix n n R) : M.det = 1 := by
rw [Fintype.card_eq_zero_iff] at h
suffices M = 1 by simp [this]
ext i
exact h.elim i
|
import Mathlib.Algebra.Polynomial.Expand
import Mathlib.Algebra.Polynomial.Laurent
import Mathlib.LinearAlgebra.Matrix.Charpoly.Basic
import Mathlib.LinearAlgebra.Matrix.Reindex
import Mathlib.RingTheory.Polynomial.Nilpotent
import Mathlib.LinearAlgebra.Matrix.Charpoly.Coeff
open Matrix
open Finset Matrix Polynomial
variable {R : Type u} [CommRing R]
variable {n G : Type v} [DecidableEq n] [Fintype n]
variable {α β : Type v} [DecidableEq α]
variable {M : Matrix n n R}
variable {n G : Type v} [DecidableEq n] [Fintype n]
variable {α β : Type v} [DecidableEq α]
variable {M : Matrix n n R}
variable {α β : Type v} [DecidableEq α]
variable {M : Matrix n n R}
variable {M : Matrix n n R}
variable (M)
theorem theorem_31099 (h : Fintype.card n = 0) (M : Matrix n n R) : M.det = 1 := by
rw [Fintype.card_eq_zero_iff] at h
suffices M = 1 by simp [this]
ext i
exact (h.elim i).elim
| null |
b8576a6ff174b01bd61d8f81e2d85997ad47a52d8674facef89051ce900dab86
| null | null | null | null | null | null | 20
| 9
|
failed to elaborate eliminator, expected type is not available
|
exact (h.elim i).elim
|
case a R : Type u inst✝² : CommRing R n : Type v inst✝¹ : DecidableEq n inst✝ : Fintype n h : IsEmpty n M : Matrix n n R i j✝ : n ⊢ M i j✝ = 1 i j✝
|
The proof fails because `h.elim i` is being called with two arguments when it only expects one, leading to an elimination error. The `ext` tactic introduces both `i` and `j` as variables, but the elimination needs to handle them separately.
|
Remove the extraneous `.elim` call and directly use `h.elim` on just one variable.
|
herald
|
lme
|
train
|
HomologicalComplex.d_comp_XIsoOfEq_inv.lean
|
import Mathlib.Algebra.Homology.ComplexShape
import Mathlib.CategoryTheory.Subobject.Limits
import Mathlib.CategoryTheory.GradedObject
import Mathlib.Algebra.Homology.ShortComplex.Basic
import Mathlib.Algebra.Homology.HomologicalComplex
open HomologicalComplex
open CategoryTheory CategoryTheory.Category CategoryTheory.Limits
variable {ι : Type*}
variable (V : Type u) [Category.{v} V] [HasZeroMorphisms V]
variable (V : Type u) [Category.{v} V] [HasZeroMorphisms V]
variable {V} {c : ComplexShape ι}
theorem theorem_40862 (K : HomologicalComplex V c) {p₂ p₃ : ι} (h : p₃ = p₂) (p₁ : ι) :
K.d p₁ p₂ ≫ (K.XIsoOfEq h).inv = K.d p₁ p₃ := by
subst h; simp
|
import Mathlib.Algebra.Homology.ComplexShape
import Mathlib.CategoryTheory.Subobject.Limits
import Mathlib.CategoryTheory.GradedObject
import Mathlib.Algebra.Homology.ShortComplex.Basic
import Mathlib.Algebra.Homology.HomologicalComplex
open HomologicalComplex
open CategoryTheory CategoryTheory.Category CategoryTheory.Limits
variable {ι : Type*}
variable (V : Type u) [Category.{v} V] [HasZeroMorphisms V]
variable (V : Type u) [Category.{v} V] [HasZeroMorphisms V]
variable {V} {c : ComplexShape ι}
theorem theorem_40862 (K : HomologicalComplex V c) {p₂ p₃ : ι} (h : p₃ = p₂) (p₁ : ι) :
K.d p₁ p₂ ≫ (K.XIsoOfEq h).inv = K.d p₁ p₃ := by
exact K.d_comp_XIsoOfEq_hom p₁ h.symm
| null |
e8d11fa4dacd7096851694771854425ecaa777be994059719301623e22617d19
| null | null | null | null | null | null | 11
| 30
|
Application type mismatch: In the application
d_comp_XIsoOfEq_hom K p₁
the argument
p₁
has type
ι : Type u_1
but is expected to have type
?m.364 = ?m.365 : Prop
|
exact K.d_comp_XIsoOfEq_hom p₁ h.symm
|
ι : Type u_1 V : Type u inst✝¹ : Category.{v, u} V inst✝ : HasZeroMorphisms V c : ComplexShape ι K : HomologicalComplex V c p₂ p₃ : ι h : p₃ = p₂ p₁ : ι ⊢ K.d p₁ p₂ ≫ (K.XIsoOfEq h).inv = K.d p₁ p₃
|
The proof fails because it incorrectly uses `d_comp_XIsoOfEq_hom` with the wrong argument types. The lemma expects a proof of equality as its second argument, but `p₁` is provided instead, which is of type `ι`.
|
Use the `subst` tactic to eliminate the equality hypothesis `h` first, then simplify with `simp`.
|
herald
|
lme
|
train
|
MeasureTheory.measure_le_laverage_pos.lean
|
import Mathlib.MeasureTheory.Integral.SetIntegral
import Mathlib.MeasureTheory.Integral.Average
open MeasureTheory
open ENNReal MeasureTheory MeasureTheory.Measure Metric Set Filter TopologicalSpace Function
open scoped Topology ENNReal Convex
variable {α E F : Type*} {m0 : MeasurableSpace α} [NormedAddCommGroup E] [NormedSpace ℝ E]
[NormedAddCommGroup F] [NormedSpace ℝ F] [CompleteSpace F] {μ ν : Measure α}
{s t : Set α}
variable (μ) {f g : α → ℝ≥0∞}
variable {μ}
variable (μ)
variable {f g : α → E}
variable {f g : α → E}
variable {μ}
variable [CompleteSpace E]
variable {N : Set α} {f : α → ℝ}
variable [IsFiniteMeasure μ]
variable [IsProbabilityMeasure μ]
variable {N : Set α} {f : α → ℝ≥0∞}
variable [IsFiniteMeasure μ]
theorem theorem_7625 (hμ : μ ≠ 0) (hf : AEMeasurable f μ) :
0 < μ {x | f x ≤ ⨍⁻ a, f a ∂μ} := by
simpa using
measure_le_setLaverage_pos (measure_univ_ne_zero.2 hμ) (measure_ne_top _ _) hf.restrict
|
import Mathlib.MeasureTheory.Integral.SetIntegral
import Mathlib.MeasureTheory.Integral.Average
open MeasureTheory
open ENNReal MeasureTheory MeasureTheory.Measure Metric Set Filter TopologicalSpace Function
open scoped Topology ENNReal Convex
variable {α E F : Type*} {m0 : MeasurableSpace α} [NormedAddCommGroup E] [NormedSpace ℝ E]
[NormedAddCommGroup F] [NormedSpace ℝ F] [CompleteSpace F] {μ ν : Measure α}
{s t : Set α}
variable (μ) {f g : α → ℝ≥0∞}
variable {μ}
variable (μ)
variable {f g : α → E}
variable {f g : α → E}
variable {μ}
variable [CompleteSpace E]
variable {N : Set α} {f : α → ℝ}
variable [IsFiniteMeasure μ]
variable [IsProbabilityMeasure μ]
variable {N : Set α} {f : α → ℝ≥0∞}
variable [IsFiniteMeasure μ]
theorem theorem_7625 (hμ : μ ≠ 0) (hf : AEMeasurable f μ) :
0 < μ {x | f x ≤ ⨍⁻ a, f a ∂μ} := by
exact measure_le_setLaverage_pos (measure_univ_ne_zero.2 hμ) (measure_ne_top _ _) (hf.restrict univ)
measure_le_setLaverage_pos (measure_univ_ne_zero.2 hμ) (measure_ne_top _ _) hf.restrict
| null |
7bb18f0a44b3312c4bc170b412eb8687aee5c0a853f2c2bf829a1240181df164
| null | null | null | null | null | null | 23
| 85
|
Function expected at
AEMeasurable.restrict hf
but this term has type
AEMeasurable f (μ.restrict ?m.10815)
Note: Expected a function because this term is being applied to the argument
univ
|
exact measure_le_setLaverage_pos (measure_univ_ne_zero.2 hμ) (measure_ne_top _ _) (hf.restrict univ)
|
α : Type u_1 m0 : MeasurableSpace α μ : Measure α inst✝² : IsFiniteMeasure μ inst✝¹ : IsProbabilityMeasure μ f : α → ℝ≥0∞ inst✝ : IsFiniteMeasure μ hμ : μ ≠ 0 hf : AEMeasurable f μ ⊢ 0 < μ {x | f x ≤ ⨍⁻ (a : α), f a ∂μ}
|
The proof fails because hf.restrict is incorrectly applied to univ without proper scoping, leading to a type mismatch where a function was expected but got a restricted measurable instead.
|
Remove the redundant application of measure_le_setLaverage_pos and use simpa to properly apply the lemma with the restricted measure.
|
herald
|
lme
|
train
|
Int.modEq_neg.lean
|
import Mathlib.Data.Nat.ModEq
import Mathlib.Tactic.Abel
import Mathlib.Tactic.GCongr.Core
import Mathlib.Data.Int.ModEq
open Int
variable {m n a b c d : ℤ}
theorem theorem_36725 : a ≡ b [ZMOD -n] ↔ a ≡ b [ZMOD n] := by
simp [modEq_iff_dvd]
|
import Mathlib.Data.Nat.ModEq
import Mathlib.Tactic.Abel
import Mathlib.Tactic.GCongr.Core
import Mathlib.Data.Int.ModEq
open Int
variable {m n a b c d : ℤ}
theorem theorem_36725 : a ≡ b [ZMOD -n] ↔ a ≡ b [ZMOD n] := by
exact Int.modEq_neg_iff
| null |
08ece4e9d6fc8bd5d52ca18f93b90c8e75f0a61278436faefc06ea287adc4a7d
| null | null | null | null | null | null | 6
| 8
|
unknown constant 'Int.modEq_neg_iff'
|
exact Int.modEq_neg_iff
|
n a b : ℤ ⊢ a ≡ b [ZMOD -n] ↔ a ≡ b [ZMOD n]
|
The proof fails because it references an unknown constant 'Int.modEq_neg_iff' which doesn't exist in the imported modules.
|
Use the existing 'modEq_iff_dvd' lemma and simplify to prove the equivalence.
|
herald
|
lme
|
train
|
Rat.inv_divInt.lean
|
import Batteries.Data.Rat.Basic
import Batteries.Tactic.SeqFocus
import Batteries.Data.Rat.Lemmas
open Rat
theorem theorem_2786 (n d : Int) : (n /. d).inv = d /. n := by
if z : d = 0 then simp [z] else
cases e : n /. d; rcases divInt_num_den z e with ⟨g, zg, rfl, rfl⟩
simp [inv_def, divInt_mul_right zg]
|
import Batteries.Data.Rat.Basic
import Batteries.Tactic.SeqFocus
import Batteries.Data.Rat.Lemmas
open Rat
theorem theorem_2786 (n d : Int) : (n /. d).inv = d /. n := by
by_cases z : n /. d = 0; · simp [z]
cases e : n /. d; rcases divInt_num_den z e with ⟨g, zg, rfl, rfl⟩
simp [inv_def, divInt_mul_right zg]
| null |
75d9a1acf2fbbee698deff1d98958db2659aff553f4aeda4a7a0643514d95481
| null | null | null | null | null | null | 5
| 27
|
unsolved goals
case pos
n d : ℤ
z : n /. d = 0
⊢ 0 = d /. n
|
by_cases z : n /. d = 0; · simp [z]
|
case pos n d : ℤ z : n /. d = 0 ⊢ (n /. d).inv = d /. n case neg n d : ℤ z : ¬n /. d = 0 ⊢ (n /. d).inv = d /. n
|
The proof fails because the first case `z : n /. d = 0` doesn't properly handle the case when the denominator `d` is zero, which makes `d /. n` undefined.
|
Check if the denominator `d` is zero first before handling the case where the rational number is zero.
|
herald
|
lme
|
train
|
TendstoUniformly.im.lean
|
import Mathlib.Analysis.Complex.Basic
import Mathlib.Topology.FiberBundle.IsHomeomorphicTrivialBundle
import Mathlib.Analysis.Complex.ReImTopology
open TendstoUniformly
open Set
open Complex Metric
variable {s t : Set ℝ}
variable {α ι : Type*}
theorem theorem_7549 {f : ι → α → ℂ} {p : Filter ι} {g : α → ℂ}
(hf : TendstoUniformly f g p) :
TendstoUniformly (fun n x => (f n x).im) (fun y => (g y).im) p := by
apply UniformContinuous.comp_tendstoUniformly uniformlyContinous_im hf
|
import Mathlib.Analysis.Complex.Basic
import Mathlib.Topology.FiberBundle.IsHomeomorphicTrivialBundle
import Mathlib.Analysis.Complex.ReImTopology
open TendstoUniformly
open Set
open Complex Metric
variable {s t : Set ℝ}
variable {α ι : Type*}
theorem theorem_7549 {f : ι → α → ℂ} {p : Filter ι} {g : α → ℂ}
(hf : TendstoUniformly f g p) :
TendstoUniformly (fun n x => (f n x).im) (fun y => (g y).im) p := by
exact hf.comp Complex.im_clm Complex.im_clm.uniformContinuous
| null |
f944dff673b38fa3f6908df60058f7897f6e5057361fb4b3c4fa6b1721b88f04
| null | null | null | null | null | null | 11
| 16
|
unknown constant 'Complex.im_clm'
|
exact hf.comp Complex.im_clm Complex.im_clm.uniformContinuous
|
α : Type u_1 ι : Type u_2 f : ι → α → ℂ p : Filter ι g : α → ℂ hf : TendstoUniformly f g p ⊢ TendstoUniformly (fun n x => (f n x).im) (fun y => (g y).im) p
|
The proof fails because it references an undefined constant 'Complex.im_clm', which should be a continuous linear map for the complex imaginary part. The module imports don't expose this constant.
|
Use the uniformly continuous function uniformlyContinous_im instead of the missing linear map constant.
|
herald
|
lme
|
train
|
HurwitzZeta.tendsto_hurwitzZetaEven_sub_one_div_nhds_one.lean
|
import Mathlib.NumberTheory.LSeries.AbstractFuncEq
import Mathlib.NumberTheory.ModularForms.JacobiTheta.Bounds
import Mathlib.Analysis.SpecialFunctions.Gamma.Deligne
import Mathlib.NumberTheory.LSeries.MellinEqDirichlet
import Mathlib.NumberTheory.LSeries.Basic
import Mathlib.Analysis.Complex.RemovableSingularity
import Mathlib.NumberTheory.LSeries.HurwitzZetaEven
open HurwitzZeta
open Complex Filter Topology Asymptotics Real Set Classical MeasureTheory
theorem theorem_22969 (a : UnitAddCircle) :
Tendsto (fun s ↦ hurwitzZetaEven a s - 1 / (s - 1) / Gammaℝ s) (𝓝 1)
(𝓝 (hurwitzZetaEven a 1)) := by
simpa only [one_div, sub_self, div_zero, Gammaℝ_one, div_one, sub_zero] using
(differentiableAt_hurwitzZetaEven_sub_one_div a).continuousAt.tendsto
|
import Mathlib.NumberTheory.LSeries.AbstractFuncEq
import Mathlib.NumberTheory.ModularForms.JacobiTheta.Bounds
import Mathlib.Analysis.SpecialFunctions.Gamma.Deligne
import Mathlib.NumberTheory.LSeries.MellinEqDirichlet
import Mathlib.NumberTheory.LSeries.Basic
import Mathlib.Analysis.Complex.RemovableSingularity
import Mathlib.NumberTheory.LSeries.HurwitzZetaEven
open HurwitzZeta
open Complex Filter Topology Asymptotics Real Set Classical MeasureTheory
theorem theorem_22969 (a : UnitAddCircle) :
Tendsto (fun s ↦ hurwitzZetaEven a s - 1 / (s - 1) / Gammaℝ s) (𝓝 1)
(𝓝 (hurwitzZetaEven a 1)) := by
exact
(differentiableAt_hurwitzZetaEven_sub_one_div a).continuousAt.tendsto
| null |
0b9d133bee1f084d9423977a86c9fa2b06562f3395e3addc10abd290b77d05ce
| null | null | null | null | null | null | 8
| 2
|
type mismatch
ContinuousAt.tendsto (DifferentiableAt.continuousAt (differentiableAt_hurwitzZetaEven_sub_one_div a))
has type
Tendsto (fun s => hurwitzZetaEven a s - 1 / (s - 1) / s.Gammaℝ) (𝓝 1)
(𝓝 (hurwitzZetaEven a 1 - 1 / (1 - 1) / Gammaℝ 1)) : Prop
but is expected to have type
Tendsto (fun s => hurwitzZetaEven a s - 1 / (s - 1) / s.Gammaℝ) (𝓝 1) (𝓝 (hurwitzZetaEven a 1)) : Prop
|
exact
|
a : UnitAddCircle ⊢ Tendsto (fun s => hurwitzZetaEven a s - 1 / (s - 1) / s.Gammaℝ) (𝓝 1) (𝓝 (hurwitzZetaEven a 1))
|
The proof fails because the expected limit value is simply `hurwitzZetaEven a 1`, while the actual limit value from the continuity assumption includes additional terms `1 / (1 - 1) / Gammaℝ 1`.
|
Simplify the limit expression using algebraic manipulations to match the expected form by canceling out the additional terms.
|
herald
|
lme
|
train
|
Real.Angle.toIocMod_toReal.lean
|
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic
import Mathlib.Analysis.Normed.Group.AddCircle
import Mathlib.Algebra.CharZero.Quotient
import Mathlib.Topology.Instances.Sign
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle
open Real
open Angle
open Real
theorem theorem_19889 (θ : Angle) : toIocMod two_pi_pos (-π) θ.toReal = θ.toReal := by
induction θ using Real.Angle.induction_on
rw [toReal_coe]
exact toIocMod_toIocMod _ _ _ _
|
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic
import Mathlib.Analysis.Normed.Group.AddCircle
import Mathlib.Algebra.CharZero.Quotient
import Mathlib.Topology.Instances.Sign
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle
open Real
open Angle
open Real
theorem theorem_19889 (θ : Angle) : toIocMod two_pi_pos (-π) θ.toReal = θ.toReal := by
rw [toReal_coe]
rw [toReal_coe]
exact toIocMod_toIocMod _ _ _ _
| null |
f73ea6296c3ab392b817476b26c513b47693324cde896345f0e2fa73e05592f5
| null | null | null | null | null | null | 7
| 6
|
tactic 'rewrite' failed, did not find instance of the pattern in the target expression
(↑?θ).toReal
θ : Angle
⊢ toIocMod two_pi_pos (-π) θ.toReal = θ.toReal
|
rw [toReal_coe]
|
θ : Angle ⊢ toIocMod two_pi_pos (-π) θ.toReal = θ.toReal
|
The proof fails because it attempts to rewrite θ.toReal using toReal_coe twice, but θ is already an Angle type, not a coercion, so the rewrite pattern doesn't match.
|
Use angle induction via Real.Angle.induction_on before applying the rewrites.
|
herald
|
lme
|
train
|
CategoryTheory.rightDistributor_ext₂_left.lean
|
import Mathlib.CategoryTheory.Preadditive.AdditiveFunctor
import Mathlib.CategoryTheory.Monoidal.Functor
import Mathlib.CategoryTheory.Monoidal.Preadditive
open CategoryTheory
open scoped Classical
open CategoryTheory.Limits
open CategoryTheory.MonoidalCategory
variable (C : Type*) [Category C] [Preadditive C] [MonoidalCategory C]
variable {C}
variable [MonoidalPreadditive C]
variable [MonoidalPreadditive C]
variable [HasFiniteBiproducts C]
theorem theorem_41073 {J : Type} [Fintype J]
{f : J → C} {X Y Z : C} {g h : ((⨁ f) ⊗ X) ⊗ Y ⟶ Z}
(w : ∀ j, ((biproduct.ι f j ▷ X) ▷ Y) ≫ g = ((biproduct.ι f j ▷ X) ▷ Y) ≫ h) :
g = h := by
apply (cancel_epi (α_ _ _ _).inv).mp
ext
simp [w]
|
import Mathlib.CategoryTheory.Preadditive.AdditiveFunctor
import Mathlib.CategoryTheory.Monoidal.Functor
import Mathlib.CategoryTheory.Monoidal.Preadditive
open CategoryTheory
open scoped Classical
open CategoryTheory.Limits
open CategoryTheory.MonoidalCategory
variable (C : Type*) [Category C] [Preadditive C] [MonoidalCategory C]
variable {C}
variable [MonoidalPreadditive C]
variable [MonoidalPreadditive C]
variable [HasFiniteBiproducts C]
theorem theorem_41073 {J : Type} [Fintype J]
{f : J → C} {X Y Z : C} {g h : ((⨁ f) ⊗ X) ⊗ Y ⟶ Z}
(w : ∀ j, ((biproduct.ι f j ▷ X) ▷ Y) ≫ g = ((biproduct.ι f j ▷ X) ▷ Y) ≫ h) :
g = h := by
apply (cancel_epi (α_ _ _ _).inv).mp
ext
simp [← Category.assoc, MonoidalCategory.associator_inv_naturality, w]
| null |
9e40210ab568a32742eada5a2a147bafad670d998ba27555e02ac5994d8882bd
| null | null | null | null | null | null | 15
| 13
|
unsolved goals
case w
C : Type u_1
inst✝⁶ : Category.{u_2, u_1} C
inst✝⁵ : Preadditive C
inst✝⁴ : MonoidalCategory C
inst✝³ inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
f : J → C
X Y Z : C
g h : ((⨁ f) ⊗ X) ⊗ Y ⟶ Z
w : ∀ (j : J), biproduct.ι f j ▷ X ▷ Y ≫ g = biproduct.ι f j ▷ X ▷ Y ≫ h
j✝ : J
⊢ ((((α_ (f j✝) X Y).inv ≫ biproduct.ι f j✝ ▷ X ▷ Y) ≫ (α_ (⨁ f) X Y).hom) ≫ (α_ (⨁ f) X Y).inv) ≫ g =
((((α_ (f j✝) X Y).inv ≫ biproduct.ι f j✝ ▷ X ▷ Y) ≫ (α_ (⨁ f) X Y).hom) ≫ (α_ (⨁ f) X Y).inv) ≫ h
|
g = h := by
|
C : Type u_1 inst✝⁶ : Category.{u_2, u_1} C inst✝⁵ : Preadditive C inst✝⁴ : MonoidalCategory C inst✝³ inst✝² : MonoidalPreadditive C inst✝¹ : HasFiniteBiproducts C J : Type inst✝ : Fintype J f : J → C X Y Z : C g h : ((⨁ f) ⊗ X) ⊗ Y ⟶ Z w : ∀ (j : J), biproduct.ι f j ▷ X ▷ Y ≫ g = biproduct.ι f j ▷ X ▷ Y ≫ h ⊢ g = h
|
The proof fails because the `simp` tactic with additional lemmas is causing unnecessary complexity by introducing associators, when the goal can be solved more directly using just the hypothesis `w`.
|
Remove unnecessary lemmas from `simp` and use only the given hypothesis `w` to simplify the goal.
|
herald
|
lme
|
train
|
MeasureTheory.eLpNorm'_measure_zero_of_pos.lean
|
import Mathlib.Analysis.NormedSpace.IndicatorFunction
import Mathlib.MeasureTheory.Function.EssSup
import Mathlib.MeasureTheory.Function.AEEqFun
import Mathlib.MeasureTheory.Function.SpecialFunctions.Basic
import Mathlib.MeasureTheory.Function.LpSeminorm.Basic
open MeasureTheory
open TopologicalSpace MeasureTheory Filter
open scoped NNReal ENNReal Topology
variable {α E F G : Type*} {m m0 : MeasurableSpace α} {p : ℝ≥0∞} {q : ℝ} {μ ν : Measure α}
[NormedAddCommGroup E] [NormedAddCommGroup F] [NormedAddCommGroup G]
variable [MeasurableSpace α]
theorem theorem_11129 {f : α → F} (hq_pos : 0 < q) :
eLpNorm' f q (0 : Measure α) = 0 := by
simp [eLpNorm', hq_pos]
|
import Mathlib.Analysis.NormedSpace.IndicatorFunction
import Mathlib.MeasureTheory.Function.EssSup
import Mathlib.MeasureTheory.Function.AEEqFun
import Mathlib.MeasureTheory.Function.SpecialFunctions.Basic
import Mathlib.MeasureTheory.Function.LpSeminorm.Basic
open MeasureTheory
open TopologicalSpace MeasureTheory Filter
open scoped NNReal ENNReal Topology
variable {α E F G : Type*} {m m0 : MeasurableSpace α} {p : ℝ≥0∞} {q : ℝ} {μ ν : Measure α}
[NormedAddCommGroup E] [NormedAddCommGroup F] [NormedAddCommGroup G]
variable [MeasurableSpace α]
theorem theorem_11129 {f : α → F} (hq_pos : 0 < q) :
eLpNorm' f q (0 : Measure α) = 0 := by
simp [eLpNorm']
| null |
c650feb43f867f956eabe20d7838291194ea1298c3bf7412147d55f7a48cd18d
| null | null | null | null | null | null | 10
| 40
|
unsolved goals
α : Type u_1
F : Type u_3
q : ℝ
inst✝¹ : NormedAddCommGroup F
inst✝ : MeasurableSpace α
f : α → F
hq_pos : 0 < q
⊢ 0 < q
|
eLpNorm' f q (0 : Measure α) = 0 := by
|
α : Type u_1 F : Type u_3 q : ℝ inst✝¹ : NormedAddCommGroup F inst✝ : MeasurableSpace α f : α → F hq_pos : 0 < q ⊢ eLpNorm' f q 0 = 0
|
The proof fails because the simplifier cannot fully simplify the expression without knowing that the variable q is positive, despite hq_pos being in the context.
|
Add the hypothesis hq_pos to the list of simplification lemmas to discharge the remaining goal.
|
herald
|
lme
|
train
|
inf_sdiff_eq_bot_iff.lean
|
import Mathlib.Order.Heyting.Basic
import Mathlib.Order.BooleanAlgebra
open Function OrderDual
variable {α : Type u} {β : Type*} {w x y z : α}
variable [GeneralizedBooleanAlgebra α]
theorem theorem_4321 (hz : z ≤ y) (hx : x ≤ y) : z ⊓ y \ x = ⊥ ↔ z ≤ x := by
rw [← disjoint_iff]
exact disjoint_sdiff_iff_le hz hx
|
import Mathlib.Order.Heyting.Basic
import Mathlib.Order.BooleanAlgebra
open Function OrderDual
variable {α : Type u} {β : Type*} {w x y z : α}
variable [GeneralizedBooleanAlgebra α]
theorem theorem_4321 (hz : z ≤ y) (hx : x ≤ y) : z ⊓ y \ x = ⊥ ↔ z ≤ x := by
rw [disjoint_iff]
exact disjoint_sdiff_iff_le hz hx
| null |
452c80bff7f0fa2f126f3bd34acf3711da8a7e12d625fe2ff372510513d8abf0
| null | null | null | null | null | null | 8
| 6
|
tactic 'rewrite' failed, did not find instance of the pattern in the target expression
Disjoint ?m.707 ?m.708
α : Type u
x y z : α
inst✝ : GeneralizedBooleanAlgebra α
hz : z ≤ y
hx : x ≤ y
⊢ z ⊓ y \ x = ⊥ ↔ z ≤ x
|
rw [disjoint_iff]
|
α : Type u x y z : α inst✝ : GeneralizedBooleanAlgebra α hz : z ≤ y hx : x ≤ y ⊢ z ⊓ y \ x = ⊥ ↔ z ≤ x
|
The proof fails because 'disjoint_iff' requires the target to be in the form 'Disjoint a b', but the current goal is 'z ⊓ y \\\\ x = ⊥' which is not syntactically the same, though semantically equivalent.
|
Use the reverse rewrite direction '← disjoint_iff' to convert the goal into the required Disjoint form.
|
herald
|
lme
|
train
|
RingHom.codomain_trivial_iff_map_one_eq_zero.lean
|
import Mathlib.Algebra.Group.Pi.Basic
import Mathlib.Algebra.GroupWithZero.Hom
import Mathlib.Algebra.Ring.Defs
import Mathlib.Algebra.Ring.Basic
import Mathlib.Algebra.Ring.Hom.Defs
open RingHom
open Function
variable {F α β γ : Type*}
variable [NonUnitalNonAssocSemiring α] [NonUnitalNonAssocSemiring β] [FunLike F α β]
variable [NonUnitalRingHomClass F α β]
variable [NonUnitalRingHomClass F α β]
variable [NonUnitalNonAssocSemiring α] [NonUnitalNonAssocSemiring β]
variable [NonUnitalNonAssocSemiring α] [NonUnitalNonAssocSemiring β]
variable (f : α →ₙ+* β) {x y : α}
variable (f : α →ₙ+* β) {x y : α}
variable [NonUnitalNonAssocSemiring α] [NonUnitalNonAssocSemiring β]
variable [NonUnitalNonAssocSemiring γ]
variable (g : β →ₙ+* γ) (f : α →ₙ+* β)
variable [FunLike F α β]
variable {_ : NonAssocSemiring α} {_ : NonAssocSemiring β} [RingHomClass F α β]
variable {_ : NonAssocSemiring α} {_ : NonAssocSemiring β}
variable {_ : NonAssocSemiring α} {_ : NonAssocSemiring β} (f : α →+* β) {x y : α}
theorem theorem_27796 : (0 : β) = 1 ↔ f 1 = 0 := by
rw [map_one, eq_comm]
|
import Mathlib.Algebra.Group.Pi.Basic
import Mathlib.Algebra.GroupWithZero.Hom
import Mathlib.Algebra.Ring.Defs
import Mathlib.Algebra.Ring.Basic
import Mathlib.Algebra.Ring.Hom.Defs
open RingHom
open Function
variable {F α β γ : Type*}
variable [NonUnitalNonAssocSemiring α] [NonUnitalNonAssocSemiring β] [FunLike F α β]
variable [NonUnitalRingHomClass F α β]
variable [NonUnitalRingHomClass F α β]
variable [NonUnitalNonAssocSemiring α] [NonUnitalNonAssocSemiring β]
variable [NonUnitalNonAssocSemiring α] [NonUnitalNonAssocSemiring β]
variable (f : α →ₙ+* β) {x y : α}
variable (f : α →ₙ+* β) {x y : α}
variable [NonUnitalNonAssocSemiring α] [NonUnitalNonAssocSemiring β]
variable [NonUnitalNonAssocSemiring γ]
variable (g : β →ₙ+* γ) (f : α →ₙ+* β)
variable [FunLike F α β]
variable {_ : NonAssocSemiring α} {_ : NonAssocSemiring β} [RingHomClass F α β]
variable {_ : NonAssocSemiring α} {_ : NonAssocSemiring β}
variable {_ : NonAssocSemiring α} {_ : NonAssocSemiring β} (f : α →+* β) {x y : α}
theorem theorem_27796 : (0 : β) = 1 ↔ f 1 = 0 := by
simp [map_one f]
| null |
57203f6bfa4bfffe4dafa9090d55ef6f31fdc3686b438e251b89918439fd01c0
| null | null | null | null | null | null | 20
| 49
|
unsolved goals
α : Type u_2
β : Type u_3
inst✝⁷ : NonUnitalNonAssocSemiring α
inst✝⁶ : NonUnitalNonAssocSemiring β
inst✝⁵ : NonUnitalNonAssocSemiring α
inst✝⁴ : NonUnitalNonAssocSemiring β
inst✝³ : NonUnitalNonAssocSemiring α
inst✝² : NonUnitalNonAssocSemiring β
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : NonUnitalNonAssocSemiring β
x✝¹ : NonAssocSemiring α
x✝ : NonAssocSemiring β
f : α →+* β
⊢ 0 = 1 ↔ 1 = 0
|
theorem theorem_27796 : (0 : β) = 1 ↔ f 1 = 0 := by
|
α : Type u_2 β : Type u_3 inst✝⁷ : NonUnitalNonAssocSemiring α inst✝⁶ : NonUnitalNonAssocSemiring β inst✝⁵ : NonUnitalNonAssocSemiring α inst✝⁴ : NonUnitalNonAssocSemiring β inst✝³ : NonUnitalNonAssocSemiring α inst✝² : NonUnitalNonAssocSemiring β inst✝¹ : NonUnitalNonAssocSemiring α inst✝ : NonUnitalNonAssocSemiring β x✝¹ : NonAssocSemiring α x✝ : NonAssocSemiring β f : α →+* β ⊢ 0 = 1 ↔ f 1 = 0
|
The proof fails because `simp [map_one f]` only simplifies `f 1` to `1` but doesn't address the required equivalence between `0 = 1` and `1 = 0`. The goal remains unsolved after simplification.
|
Use `rw [map_one, eq_comm]` to both apply the ring homomorphism property and swap the sides of the equality in the goal.
|
herald
|
lme
|
train
|
Affine.Simplex.sum_reflectionCircumcenterWeightsWithCircumcenter.lean
|
import Mathlib.Geometry.Euclidean.Sphere.Basic
import Mathlib.LinearAlgebra.AffineSpace.FiniteDimensional
import Mathlib.Tactic.DeriveFintype
import Mathlib.Geometry.Euclidean.Circumcenter
open Affine
open Simplex
open RealInnerProductSpace
variable {V : Type*} {P : Type*} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P]
[NormedAddTorsor V P]
open AffineSubspace
open Finset AffineSubspace EuclideanGeometry
variable {V : Type*} {P : Type*} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P]
[NormedAddTorsor V P]
open PointsWithCircumcenterIndex
theorem theorem_24435 {n : ℕ} {i₁ i₂ : Fin (n + 1)}
(h : i₁ ≠ i₂) : ∑ i, reflectionCircumcenterWeightsWithCircumcenter i₁ i₂ i = 1 := by
simp_rw [sum_pointsWithCircumcenter, reflectionCircumcenterWeightsWithCircumcenter, sum_ite,
sum_const, filter_or, filter_eq']
rw [card_union_of_disjoint]
· set_option simprocs false in simp
· simpa only [if_true, mem_univ, disjoint_singleton] using h
|
import Mathlib.Geometry.Euclidean.Sphere.Basic
import Mathlib.LinearAlgebra.AffineSpace.FiniteDimensional
import Mathlib.Tactic.DeriveFintype
import Mathlib.Geometry.Euclidean.Circumcenter
open Affine
open Simplex
open RealInnerProductSpace
variable {V : Type*} {P : Type*} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P]
[NormedAddTorsor V P]
open AffineSubspace
open Finset AffineSubspace EuclideanGeometry
variable {V : Type*} {P : Type*} [NormedAddCommGroup V] [InnerProductSpace ℝ V] [MetricSpace P]
[NormedAddTorsor V P]
open PointsWithCircumcenterIndex
theorem theorem_24435 {n : ℕ} {i₁ i₂ : Fin (n + 1)}
(h : i₁ ≠ i₂) : ∑ i, reflectionCircumcenterWeightsWithCircumcenter i₁ i₂ i = 1 := by
simp_rw [sum_pointsWithCircumcenter, reflectionCircumcenterWeightsWithCircumcenter, sum_ite,
sum_const, filter_or, filter_eq']
field_simp [Nat.cast_succ]
· set_option simprocs false in simp
· simpa only [if_true, mem_univ, disjoint_singleton] using h
| null |
761bc473f22f48e523d609a7106f97d4ee57b918682880963857dd7f29721aa9
| null | null | null | null | null | null | 18
| 33
|
simp made no progress
|
· set_option simprocs false in simp
|
n : ℕ i₁ i₂ : Fin (n + 1) h : i₁ ≠ i₂ ⊢ ↑(#({i₁} ∪ {i₂})) + -1 = 1
|
The proof fails because `field_simp` cannot simplify the goal `↑(#({i₁} ∪ {i₂})) + -1 = 1` with the given assumptions, while the correct proof uses `rw [card_union_of_disjoint]` to properly handle the cardinality of the union of two finite sets.
|
Replace `field_simp` with a rewrite using `card_union_of_disjoint` to properly handle set cardinality calculation.
|
herald
|
lme
|
train
|
AddChar.exists_divisor_of_not_isPrimitive.lean
|
import Mathlib.NumberTheory.Cyclotomic.PrimitiveRoots
import Mathlib.FieldTheory.Finite.Trace
import Mathlib.Algebra.Group.AddChar
import Mathlib.Data.ZMod.Units
import Mathlib.Analysis.Complex.Polynomial.Basic
import Mathlib.NumberTheory.LegendreSymbol.AddCharacter
open AddChar
variable {R : Type u} [CommRing R] {R' : Type v} [CommMonoid R']
variable {N : ℕ} [NeZero N] {R : Type*} [CommRing R] (e : AddChar (ZMod N) R)
theorem theorem_3937 (he : ¬e.IsPrimitive) :
∃ d : ℕ, d ∣ N ∧ d < N ∧ e.mulShift d = 1 := by
simp_rw [IsPrimitive, not_forall, not_ne_iff] at he
rcases he with ⟨b, hb_ne, hb⟩
-- We have `AddChar.mulShift e b = 1`, but `b ≠ 0`.
obtain ⟨d, hd, u, hu, rfl⟩ := b.eq_unit_mul_divisor
refine ⟨d, hd, lt_of_le_of_ne (Nat.le_of_dvd (NeZero.pos _) hd) ?_, ?_⟩
· exact fun h ↦ by simp only [h, ZMod.natCast_self, mul_zero, ne_eq, not_true_eq_false] at hb_ne
· rw [← mulShift_unit_eq_one_iff _ hu, ← hb, mul_comm]
ext1 y
rw [mulShift_apply, mulShift_apply, mulShift_apply, mul_assoc]
|
import Mathlib.NumberTheory.Cyclotomic.PrimitiveRoots
import Mathlib.FieldTheory.Finite.Trace
import Mathlib.Algebra.Group.AddChar
import Mathlib.Data.ZMod.Units
import Mathlib.Analysis.Complex.Polynomial.Basic
import Mathlib.NumberTheory.LegendreSymbol.AddCharacter
open AddChar
variable {R : Type u} [CommRing R] {R' : Type v} [CommMonoid R']
variable {N : ℕ} [NeZero N] {R : Type*} [CommRing R] (e : AddChar (ZMod N) R)
theorem theorem_3937 (he : ¬e.IsPrimitive) :
∃ d : ℕ, d ∣ N ∧ d < N ∧ e.mulShift d = 1 := by
simp_rw [IsPrimitive, not_forall, not_ne_iff] at he
rcases he with ⟨b, hb_ne, hb⟩
-- We have `AddChar.mulShift e b = 1`, but `b ≠ 0`.
use (b : ℕ), by contrapose! hb_ne; exact ZMod.natCast_zmod_eq_zero_iff_dvd.mpr hb_ne
refine ⟨d, hd, lt_of_le_of_ne (Nat.le_of_dvd (NeZero.pos _) hd) ?_, ?_⟩
· exact fun h ↦ by simp only [h, ZMod.natCast_self, mul_zero, ne_eq, not_true_eq_false] at hb_ne
· rw [← mulShift_unit_eq_one_iff _ hu, ← hb, mul_comm]
ext1 y
rw [mulShift_apply, mulShift_apply, mulShift_apply, mul_assoc]
| null |
eb204a8c8b497b362ac834b29f555b0494d8e0f05e9ee026ba2457ceec0ede6c
| null | null | null | null | null | null | 11
| 6
|
type mismatch
b
has type
ZMod N : Type
but is expected to have type
ℕ : Type
|
use (b : ℕ), by contrapose! hb_ne; exact ZMod.natCast_zmod_eq_zero_iff_dvd.mpr hb_ne
|
N : ℕ inst✝¹ : NeZero N R : Type u_1 inst✝ : CommRing R e : AddChar (ZMod N) R he : ¬e.IsPrimitive ⊢ ∃ d, d ∣ N ∧ d < N ∧ e.mulShift ↑d = 1
|
The proof fails because it tries to use `b` as a natural number (ℕ) when it's actually of type `ZMod N`.
|
Convert the `ZMod N` value `b` to a natural number using `b.eq_unit_mul_divisor` before using it in the proof.
|
herald
|
lme
|
train
|
CategoryTheory.IsInitial.isVanKampenColimit.lean
|
import Mathlib.CategoryTheory.Adjunction.FullyFaithful
import Mathlib.CategoryTheory.Adjunction.Limits
import Mathlib.CategoryTheory.Limits.Shapes.Pullback.CommSq
import Mathlib.CategoryTheory.Limits.Shapes.StrictInitial
import Mathlib.CategoryTheory.Limits.FunctorCategory.Basic
import Mathlib.CategoryTheory.Limits.Constructions.FiniteProductsOfBinaryProducts
import Mathlib.CategoryTheory.Limits.VanKampen
open CategoryTheory
open IsInitial
open CategoryTheory.Limits
variable {J : Type v'} [Category.{u'} J] {C : Type u} [Category.{v} C]
variable {K : Type*} [Category K] {D : Type*} [Category D]
variable {K : Type*} [Category K] {D : Type*} [Category D]
theorem theorem_28460 [HasStrictInitialObjects C] {X : C} (h : IsInitial X) :
IsVanKampenColimit (asEmptyCocone X) := by
intro F' c' α f hf hα
have : F' = Functor.empty C := by apply Functor.hext <;> rintro ⟨⟨⟩⟩
subst this
haveI := h.isIso_to f
refine ⟨by rintro _ ⟨⟨⟩⟩,
fun _ => ⟨IsColimit.ofIsoColimit h (Cocones.ext (asIso f).symm <| by rintro ⟨⟨⟩⟩)⟩⟩
|
import Mathlib.CategoryTheory.Adjunction.FullyFaithful
import Mathlib.CategoryTheory.Adjunction.Limits
import Mathlib.CategoryTheory.Limits.Shapes.Pullback.CommSq
import Mathlib.CategoryTheory.Limits.Shapes.StrictInitial
import Mathlib.CategoryTheory.Limits.FunctorCategory.Basic
import Mathlib.CategoryTheory.Limits.Constructions.FiniteProductsOfBinaryProducts
import Mathlib.CategoryTheory.Limits.VanKampen
open CategoryTheory
open IsInitial
open CategoryTheory.Limits
variable {J : Type v'} [Category.{u'} J] {C : Type u} [Category.{v} C]
variable {K : Type*} [Category K] {D : Type*} [Category D]
variable {K : Type*} [Category K] {D : Type*} [Category D]
theorem theorem_28460 [HasStrictInitialObjects C] {X : C} (h : IsInitial X) :
IsVanKampenColimit (asEmptyCocone X) := by
intro F' c' α f hf hα
have : F' = Functor.empty C := by apply Functor.hext <;> rintro ⟨⟨⟩⟩
subst this
have hα_id : α = NatTrans.id _ := by ext ⟨⟩
refine ⟨by rintro _ ⟨⟨⟩⟩,
fun _ => ⟨IsColimit.ofIsoColimit h (Cocones.ext (asIso f).symm <| by rintro ⟨⟨⟩⟩)⟩⟩
| null |
386a928631b536ff35a6cd910e1837ac0fbc718add8707cd165e4e84862892c6
| null | null | null | null | null | null | 14
| 36
|
unsolved goals
case w.h.mk
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasStrictInitialObjects C
X : C
h : IsInitial X
c' : Cocone (Functor.empty C)
α : Functor.empty C ⟶ Functor.empty C
f : c'.pt ⟶ (asEmptyCocone X).pt
hf : α ≫ (asEmptyCocone X).ι = c'.ι ≫ (Functor.const (Discrete PEmpty.{1})).map f
hα : NatTrans.Equifibered α
as✝ : PEmpty.{1}
⊢ α.app { as := as✝ } = (NatTrans.id (Functor.empty C)).app { as := as✝ }
|
have hα_id : α = NatTrans.id _ := by ext ⟨⟩
|
C : Type u inst✝¹ : Category.{v, u} C inst✝ : HasStrictInitialObjects C X : C h : IsInitial X c' : Cocone (Functor.empty C) α : Functor.empty C ⟶ Functor.empty C f : c'.pt ⟶ (asEmptyCocone X).pt hf : α ≫ (asEmptyCocone X).ι = c'.ι ≫ (Functor.const (Discrete PEmpty.{1})).map f hα : NatTrans.Equifibered α ⊢ α = NatTrans.id (Functor.empty C)
|
The proof fails because it attempts to prove `α = NatTrans.id _` by extensionality but doesn't properly handle the isomorphism property of `f`, which is required for the `asIso` construction later.
|
Add an instance showing that `f` is an isomorphism before the final refinement.
|
herald
|
lme
|
train
|
logDeriv_mul.lean
|
import Mathlib.Analysis.Calculus.Deriv.ZPow
import Mathlib.Analysis.Calculus.LogDeriv
open Filter Function
open scoped Topology BigOperators Classical
variable {𝕜 𝕜': Type*} [NontriviallyNormedField 𝕜] [NontriviallyNormedField 𝕜']
[NormedAlgebra 𝕜 𝕜']
theorem theorem_10435 {f g : 𝕜 → 𝕜'} (x : 𝕜) (hf : f x ≠ 0) (hg : g x ≠ 0)
(hdf : DifferentiableAt 𝕜 f x) (hdg : DifferentiableAt 𝕜 g x) :
logDeriv (fun z => f z * g z) x = logDeriv f x + logDeriv g x := by
simp only [logDeriv_apply, deriv_mul hdf hdg]
field_simp [mul_comm]
|
import Mathlib.Analysis.Calculus.Deriv.ZPow
import Mathlib.Analysis.Calculus.LogDeriv
open Filter Function
open scoped Topology BigOperators Classical
variable {𝕜 𝕜': Type*} [NontriviallyNormedField 𝕜] [NontriviallyNormedField 𝕜']
[NormedAlgebra 𝕜 𝕜']
theorem theorem_10435 {f g : 𝕜 → 𝕜'} (x : 𝕜) (hf : f x ≠ 0) (hg : g x ≠ 0)
(hdf : DifferentiableAt 𝕜 f x) (hdg : DifferentiableAt 𝕜 g x) :
logDeriv (fun z => f z * g z) x = logDeriv f x + logDeriv g x := by
simp only [logDeriv_apply, deriv_mul hdf hdg]
field_simp [hf, hg]
| null |
77c91c2d0137c941c89966c6d0c8fbe3f1ed0f1658cc26ebbd6693f67e05b8e6
| null | null | null | null | null | null | 10
| 71
|
unsolved goals
𝕜 : Type u_1
𝕜' : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NontriviallyNormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
f g : 𝕜 → 𝕜'
x : 𝕜
hf : f x ≠ 0
hg : g x ≠ 0
hdf : DifferentiableAt 𝕜 f x
hdg : DifferentiableAt 𝕜 g x
⊢ f x * deriv g x = deriv g x * f x
|
logDeriv (fun z => f z * g z) x = logDeriv f x + logDeriv g x := by
|
𝕜 : Type u_1 𝕜' : Type u_2 inst✝² : NontriviallyNormedField 𝕜 inst✝¹ : NontriviallyNormedField 𝕜' inst✝ : NormedAlgebra 𝕜 𝕜' f g : 𝕜 → 𝕜' x : 𝕜 hf : f x ≠ 0 hg : g x ≠ 0 hdf : DifferentiableAt 𝕜 f x hdg : DifferentiableAt 𝕜 g x ⊢ logDeriv (fun z => f z * g z) x = logDeriv f x + logDeriv g x
|
The proof fails because the field_simp tactic cannot simplify the commutativity of multiplication in the expression f x * deriv g x = deriv g x * f x. The original proof assumes field_simp with [hf, hg] would handle this, but it doesn't address the commutativity requirement.
|
Use field_simp with mul_comm to handle the multiplication commutativity in the expression.
|
herald
|
lme
|
train
|
Matrix.det_transvection_of_ne.lean
|
import Mathlib.Data.Matrix.Basis
import Mathlib.Data.Matrix.DMatrix
import Mathlib.LinearAlgebra.Matrix.Determinant.Basic
import Mathlib.LinearAlgebra.Matrix.Reindex
import Mathlib.Tactic.FieldSimp
import Mathlib.LinearAlgebra.Matrix.Transvection
open Matrix
open Matrix
variable (n p : Type*) (R : Type u₂) {𝕜 : Type*} [Field 𝕜]
variable [DecidableEq n] [DecidableEq p]
variable [CommRing R]
variable [DecidableEq n] [DecidableEq p]
variable [CommRing R]
variable [CommRing R]
variable {R n} (i j : n)
variable [Fintype n]
theorem theorem_1671 (h : i ≠ j) (c : R) : det (transvection i j c) = 1 := by
rw [← updateRow_eq_transvection i j, det_updateRow_add_smul_self _ h, det_one]
|
import Mathlib.Data.Matrix.Basis
import Mathlib.Data.Matrix.DMatrix
import Mathlib.LinearAlgebra.Matrix.Determinant.Basic
import Mathlib.LinearAlgebra.Matrix.Reindex
import Mathlib.Tactic.FieldSimp
import Mathlib.LinearAlgebra.Matrix.Transvection
open Matrix
open Matrix
variable (n p : Type*) (R : Type u₂) {𝕜 : Type*} [Field 𝕜]
variable [DecidableEq n] [DecidableEq p]
variable [CommRing R]
variable [DecidableEq n] [DecidableEq p]
variable [CommRing R]
variable [CommRing R]
variable {R n} (i j : n)
variable [Fintype n]
theorem theorem_1671 (h : i ≠ j) (c : R) : det (transvection i j c) = 1 := by
exact det_transvection i j h c
| null |
4d0ccc4c901a483260079872f1011cf38107c313ab8ba37922e884bac9f5706f
| null | null | null | null | null | null | 14
| 8
|
unknown identifier 'det_transvection'
|
exact det_transvection i j h c
|
n : Type u_1 R : Type u₂ inst✝⁵ : DecidableEq n inst✝⁴ : CommRing R inst✝³ : DecidableEq n inst✝² inst✝¹ : CommRing R i j : n inst✝ : Fintype n h : i ≠ j c : R ⊢ (transvection i j c).det = 1
|
The proof fails because it tries to use a theorem 'det_transvection' that doesn't exist in the current context or imported libraries.
|
Use the correct theorem `det_updateRow_add_smul_self` combined with rewriting via `updateRow_eq_transvection` to prove the determinant of a transvection matrix is 1.
|
herald
|
lme
|
train
|
ProbabilityTheory.Kernel.lintegral_restrict.lean
|
import Mathlib.MeasureTheory.Integral.Bochner
import Mathlib.MeasureTheory.Measure.GiryMonad
import Mathlib.Probability.Kernel.Basic
open ProbabilityTheory
open Kernel
open MeasureTheory
open scoped MeasureTheory ENNReal NNReal
variable {α β ι : Type*} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
variable {κ : Kernel α β}
variable {s t : Set β}
theorem theorem_25986 (κ : Kernel α β) (hs : MeasurableSet s) (a : α) (f : β → ℝ≥0∞) :
∫⁻ b, f b ∂κ.restrict hs a = ∫⁻ b in s, f b ∂κ a := by
rw [restrict_apply]
|
import Mathlib.MeasureTheory.Integral.Bochner
import Mathlib.MeasureTheory.Measure.GiryMonad
import Mathlib.Probability.Kernel.Basic
open ProbabilityTheory
open Kernel
open MeasureTheory
open scoped MeasureTheory ENNReal NNReal
variable {α β ι : Type*} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
variable {κ : Kernel α β}
variable {s t : Set β}
theorem theorem_25986 (κ : Kernel α β) (hs : MeasurableSet s) (a : α) (f : β → ℝ≥0∞) :
∫⁻ b, f b ∂κ.restrict hs a = ∫⁻ b in s, f b ∂κ a := by
rw [Kernel.restrict_apply, lintegral_restrict hs]
| null |
caf610a2a80799e1402d3ab43a8a31640af83e2bd7e6fe5ccab25a708ffd2b5f
| null | null | null | null | null | null | 12
| 29
|
tactic 'rewrite' failed, did not find instance of the pattern in the target expression
∫⁻ (b : ?m.471), ?f b ∂(Kernel.restrict ?m.928 ?hs) ?a
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
s : Set β
κ : Kernel α β
hs : MeasurableSet s
a : α
f : β → ℝ≥0∞
⊢ ∫⁻ (b : β) in s, f b ∂κ a = ∫⁻ (b : β) in s, f b ∂κ a
|
rw [Kernel.restrict_apply, lintegral_restrict hs]
|
α : Type u_1 β : Type u_2 mα : MeasurableSpace α mβ : MeasurableSpace β s : Set β κ : Kernel α β hs : MeasurableSet s a : α f : β → ℝ≥0∞ ⊢ ∫⁻ (b : β) in s, f b ∂κ a = ∫⁻ (b : β) in s, f b ∂κ a
|
The proof fails because the rewrite tactic cannot find the pattern from Kernel.restrict_apply in the target expression, which is already in the desired form after the first rewrite.
|
Remove the second rewrite step since the first rewrite already simplifies the goal to a trivial equality.
|
herald
|
lme
|
train
|
Matrix.submatrix_succAbove_det_eq_negOnePow_submatrix_succAbove_det'.lean
|
import Mathlib.LinearAlgebra.Matrix.Determinant.Basic
import Mathlib.Algebra.Ring.NegOnePow
import Mathlib.LinearAlgebra.Matrix.Determinant.Misc
open Matrix
variable {R : Type*} [CommRing R]
theorem theorem_14822 {n : ℕ}
(M : Matrix (Fin n) (Fin (n + 1)) R) (hv : ∀ i, ∑ j, M i j = 0) (j₁ j₂ : Fin (n + 1)) :
(M.submatrix id (Fin.succAbove j₁)).det =
Int.negOnePow (j₁ - j₂) • (M.submatrix id (Fin.succAbove j₂)).det := by
rw [← det_transpose, transpose_submatrix,
submatrix_succAbove_det_eq_negOnePow_submatrix_succAbove_det M.transpose ?_ j₁ j₂,
← det_transpose, transpose_submatrix, transpose_transpose]
ext
simp_rw [Finset.sum_apply, transpose_apply, hv, Pi.zero_apply]
|
import Mathlib.LinearAlgebra.Matrix.Determinant.Basic
import Mathlib.Algebra.Ring.NegOnePow
import Mathlib.LinearAlgebra.Matrix.Determinant.Misc
open Matrix
variable {R : Type*} [CommRing R]
theorem theorem_14822 {n : ℕ}
(M : Matrix (Fin n) (Fin (n + 1)) R) (hv : ∀ i, ∑ j, M i j = 0) (j₁ j₂ : Fin (n + 1)) :
(M.submatrix id (Fin.succAbove j₁)).det =
Int.negOnePow (j₁ - j₂) • (M.submatrix id (Fin.succAbove j₂)).det := by
rw [submatrix_succAbove_det_eq_negOnePow_submatrix_succAbove_det M.transpose ?_ j₁ j₂, ← det_transpose, transpose_submatrix, transpose_transpose]
submatrix_succAbove_det_eq_negOnePow_submatrix_succAbove_det M.transpose ?_ j₁ j₂,
← det_transpose, transpose_submatrix, transpose_transpose]
ext
simp_rw [Finset.sum_apply, transpose_apply, hv, Pi.zero_apply]
| null |
7a3668965b8fedeb638834482242801080f5748396e6234d6b6b03791fee782e
| null | null | null | null | null | null | 9
| 6
|
tactic 'rewrite' failed, did not find instance of the pattern in the target expression
(Mᵀ.submatrix j₁.succAbove id).det
R : Type u_1
inst✝ : CommRing R
n : ℕ
M : Matrix (Fin n) (Fin (n + 1)) R
hv : ∀ (i : Fin n), ∑ j, M i j = 0
j₁ j₂ : Fin (n + 1)
⊢ (M.submatrix id j₁.succAbove).det = (↑↑j₁ - ↑↑j₂).negOnePow • (M.submatrix id j₂.succAbove).det
|
rw [submatrix_succAbove_det_eq_negOnePow_submatrix_succAbove_det M.transpose ?_ j₁ j₂, ← det_transpose, transpose_submatrix, transpose_transpose]
|
R : Type u_1 inst✝ : CommRing R n : ℕ M : Matrix (Fin n) (Fin (n + 1)) R hv : ∀ (i : Fin n), ∑ j, M i j = 0 j₁ j₂ : Fin (n + 1) ⊢ (M.submatrix id j₁.succAbove).det = (↑↑j₁ - ↑↑j₂).negOnePow • (M.submatrix id j₂.succAbove).det
|
The proof fails because the rewrite tactic cannot find the pattern `(Mᵀ.submatrix j₁.succAbove id).det` in the goal, which is needed to apply `submatrix_succAbove_det_eq_negOnePow_submatrix_succAbove_det`. The pattern doesn't match because the goal has transpositions in a different order.
|
Reorganize the proof to first apply `det_transpose` and `transpose_submatrix` lemmas before applying the main determinant equality lemma to match the expected pattern.
|
herald
|
lme
|
train
|
LinearPMap.IsClosable.closure_mono.lean
|
import Mathlib.LinearAlgebra.LinearPMap
import Mathlib.Topology.Algebra.Module.Basic
import Mathlib.Topology.Algebra.Module.LinearPMap
open LinearPMap
open IsClosable
open Topology
variable {R E F : Type*}
variable [CommRing R] [AddCommGroup E] [AddCommGroup F]
variable [Module R E] [Module R F]
variable [TopologicalSpace E] [TopologicalSpace F]
variable [CommRing R] [AddCommGroup E] [AddCommGroup F]
variable [Module R E] [Module R F]
variable [TopologicalSpace E] [TopologicalSpace F]
variable [Module R E] [Module R F]
variable [TopologicalSpace E] [TopologicalSpace F]
variable [TopologicalSpace E] [TopologicalSpace F]
variable [ContinuousAdd E] [ContinuousAdd F]
variable [TopologicalSpace R] [ContinuousSMul R E] [ContinuousSMul R F]
variable [TopologicalSpace R] [ContinuousSMul R E] [ContinuousSMul R F]
open Classical in
theorem theorem_3157 {f g : E →ₗ.[R] F} (hg : g.IsClosable) (h : f ≤ g) :
f.closure ≤ g.closure := by
refine le_of_le_graph ?_
rw [← (hg.leIsClosable h).graph_closure_eq_closure_graph]
rw [← hg.graph_closure_eq_closure_graph]
exact Submodule.topologicalClosure_mono (le_graph_of_le h)
|
import Mathlib.LinearAlgebra.LinearPMap
import Mathlib.Topology.Algebra.Module.Basic
import Mathlib.Topology.Algebra.Module.LinearPMap
open LinearPMap
open IsClosable
open Topology
variable {R E F : Type*}
variable [CommRing R] [AddCommGroup E] [AddCommGroup F]
variable [Module R E] [Module R F]
variable [TopologicalSpace E] [TopologicalSpace F]
variable [CommRing R] [AddCommGroup E] [AddCommGroup F]
variable [Module R E] [Module R F]
variable [TopologicalSpace E] [TopologicalSpace F]
variable [Module R E] [Module R F]
variable [TopologicalSpace E] [TopologicalSpace F]
variable [TopologicalSpace E] [TopologicalSpace F]
variable [ContinuousAdd E] [ContinuousAdd F]
variable [TopologicalSpace R] [ContinuousSMul R E] [ContinuousSMul R F]
variable [TopologicalSpace R] [ContinuousSMul R E] [ContinuousSMul R F]
open Classical in
theorem theorem_3157 {f g : E →ₗ.[R] F} (hg : g.IsClosable) (h : f ≤ g) :
f.closure ≤ g.closure := by
refine le_of_le_graph ?_
rw [← (hg.leIsClosable h).graph_closure_eq_closure_graph]
rw [closure_graph]
exact Submodule.topologicalClosure_mono (le_graph_of_le h)
| null |
2262e0f492985823b8c8fc2fa9d8d6dbf8ffbd27ee0b8a4724934a7d170f2682
| null | null | null | null | null | null | 21
| 29
|
unsolved goals
R : Type u_1
E : Type u_2
F : Type u_3
inst✝²⁷ : CommRing R
inst✝²⁶ : AddCommGroup E
inst✝²⁵ : AddCommGroup F
inst✝²⁴ : Module R E
inst✝²³ : Module R F
inst✝²² : TopologicalSpace E
inst✝²¹ : TopologicalSpace F
inst✝²⁰ : CommRing R
inst✝¹⁹ : AddCommGroup E
inst✝¹⁸ : AddCommGroup F
inst✝¹⁷ : Module R E
inst✝¹⁶ : Module R F
inst✝¹⁵ : TopologicalSpace E
inst✝¹⁴ : TopologicalSpace F
inst✝¹³ : Module R E
inst✝¹² : Module R F
inst✝¹¹ : TopologicalSpace E
inst✝¹⁰ : TopologicalSpace F
inst✝⁹ : TopologicalSpace E
inst✝⁸ : TopologicalSpace F
inst✝⁷ : ContinuousAdd E
inst✝⁶ : ContinuousAdd F
inst✝⁵ : TopologicalSpace R
inst✝⁴ : ContinuousSMul R E
inst✝³ : ContinuousSMul R F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f g : E →ₗ.[R] F
hg : g.IsClosable
h : f ≤ g
⊢ f.graph.topologicalClosure ≤ g.closure.graph
|
f.closure ≤ g.closure := by
|
R : Type u_1 E : Type u_2 F : Type u_3 inst✝²⁷ : CommRing R inst✝²⁶ : AddCommGroup E inst✝²⁵ : AddCommGroup F inst✝²⁴ : Module R E inst✝²³ : Module R F inst✝²² : TopologicalSpace E inst✝²¹ : TopologicalSpace F inst✝²⁰ : CommRing R inst✝¹⁹ : AddCommGroup E inst✝¹⁸ : AddCommGroup F inst✝¹⁷ : Module R E inst✝¹⁶ : Module R F inst✝¹⁵ : TopologicalSpace E inst✝¹⁴ : TopologicalSpace F inst✝¹³ : Module R E inst✝¹² : Module R F inst✝¹¹ : TopologicalSpace E inst✝¹⁰ : TopologicalSpace F inst✝⁹ : TopologicalSpace E inst✝⁸ : TopologicalSpace F inst✝⁷ : ContinuousAdd E inst✝⁶ : ContinuousAdd F inst✝⁵ : TopologicalSpace R inst✝⁴ : ContinuousSMul R E inst✝³ : ContinuousSMul R F inst✝² : TopologicalSpace R inst✝¹ : ContinuousSMul R E inst✝ : ContinuousSMul R F f g : E →ₗ.[R] F hg : g.IsClosable h : f ≤ g ⊢ f.closure ≤ g.closure
|
The proof fails because after rewriting with (hg.leIsClosable h).graph_closure_eq_closure_graph, the goal still contains g.closure.graph rather than g.graph.topologicalClosure which is needed to apply topologicalClosure_mono.
|
Use hg.graph_closure_eq_closure_graph to rewrite g.closure.graph to g.graph.topologicalClosure before applying topologicalClosure_mono.
|
herald
|
lme
|
train
|
InnerProductGeometry.angle_sub_le_pi_div_two_of_inner_eq_zero.lean
|
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan
import Mathlib.Geometry.Euclidean.Angle.Unoriented.Affine
import Mathlib.Geometry.Euclidean.Angle.Unoriented.RightAngle
open InnerProductGeometry
open scoped EuclideanGeometry
open scoped Real
open scoped RealInnerProductSpace
variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
theorem theorem_26790 {x y : V} (h : ⟪x, y⟫ = 0) :
angle x (x - y) ≤ π / 2 := by
rw [← neg_eq_zero, ← inner_neg_right] at h
rw [sub_eq_add_neg]
exact angle_add_le_pi_div_two_of_inner_eq_zero h
|
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan
import Mathlib.Geometry.Euclidean.Angle.Unoriented.Affine
import Mathlib.Geometry.Euclidean.Angle.Unoriented.RightAngle
open InnerProductGeometry
open scoped EuclideanGeometry
open scoped Real
open scoped RealInnerProductSpace
variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℝ V]
theorem theorem_26790 {x y : V} (h : ⟪x, y⟫ = 0) :
angle x (x - y) ≤ π / 2 := by
rw [← neg_eq_zero, ← inner_neg_right] at h
rw [sub_eq_add_neg]
refine (angle_le_pi_div_two_iff_inner_nonneg _ _).mpr (by rw [inner_add_right, h, add_zero]; exact inner_self_nonneg _)
| null |
030c7c6be2c859da6a57388f7feb863a6660f298a5dd0bf37e9b8c4f09d66c45
| null | null | null | null | null | null | 12
| 10
|
unknown identifier 'angle_le_pi_div_two_iff_inner_nonneg'
|
refine (angle_le_pi_div_two_iff_inner_nonneg _ _).mpr (by rw [inner_add_right, h, add_zero]; exact inner_self_nonneg _)
|
V : Type u_1 inst✝¹ : NormedAddCommGroup V inst✝ : InnerProductSpace ℝ V x y : V h : ⟪x, -y⟫ = 0 ⊢ angle x (x + -y) ≤ π / 2
|
The proof fails because it uses an undefined lemma 'angle_le_pi_div_two_iff_inner_nonneg' that doesn't exist in the current context.
|
Replace the undefined lemma with a correct existing lemma 'angle_add_le_pi_div_two_of_inner_eq_zero' that directly proves the statement.
|
herald
|
lme
|
train
|
cexp_neg_quadratic_isLittleO_abs_rpow_cocompact.lean
|
import Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform
import Mathlib.Analysis.Fourier.PoissonSummation
import Mathlib.Analysis.SpecialFunctions.Gaussian.PoissonSummation
open Real Set MeasureTheory Filter Asymptotics intervalIntegral
open scoped Real Topology FourierTransform RealInnerProductSpace
open Complex hiding exp continuous_exp abs_of_nonneg sq_abs
variable {E : Type*} [NormedAddCommGroup E]
theorem theorem_29252 {a : ℂ} (ha : a.re < 0) (b : ℂ) (s : ℝ) :
(fun x : ℝ ↦ cexp (a * x ^ 2 + b * x)) =o[cocompact ℝ] (|·| ^ s) := by
rw [cocompact_eq_atBot_atTop, isLittleO_sup]
constructor
· refine ((cexp_neg_quadratic_isLittleO_rpow_atTop ha (-b) s).comp_tendsto
Filter.tendsto_neg_atBot_atTop).congr' (Eventually.of_forall fun x ↦ ?_) ?_
· simp only [neg_mul, Function.comp_apply, ofReal_neg, neg_sq, mul_neg, neg_neg]
· refine (eventually_lt_atBot 0).mp (Eventually.of_forall fun x hx ↦ ?_)
simp only [Function.comp_apply, abs_of_neg hx]
· refine (cexp_neg_quadratic_isLittleO_rpow_atTop ha b s).congr' EventuallyEq.rfl ?_
refine (eventually_gt_atTop 0).mp (Eventually.of_forall fun x hx ↦ ?_)
simp_rw [abs_of_pos hx]
|
import Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform
import Mathlib.Analysis.Fourier.PoissonSummation
import Mathlib.Analysis.SpecialFunctions.Gaussian.PoissonSummation
open Real Set MeasureTheory Filter Asymptotics intervalIntegral
open scoped Real Topology FourierTransform RealInnerProductSpace
open Complex hiding exp continuous_exp abs_of_nonneg sq_abs
variable {E : Type*} [NormedAddCommGroup E]
theorem theorem_29252 {a : ℂ} (ha : a.re < 0) (b : ℂ) (s : ℝ) :
(fun x : ℝ ↦ cexp (a * x ^ 2 + b * x)) =o[cocompact ℝ] (|·| ^ s) := by
rw [cocompact_eq_atBot_atTop, isLittleO_sup]
constructor
· refine ((cexp_neg_quadratic_isLittleO_rpow_atTop ha (-b) s).comp_tendsto
Filter.tendsto_neg_atBot_atTop).congr' (Eventually.of_forall fun x ↦ ?_) ?_
simp [sq_neg, neg_mul_neg]
· refine (eventually_lt_atBot 0).mp (Eventually.of_forall fun x hx ↦ ?_)
simp only [Function.comp_apply, abs_of_neg hx]
· refine (cexp_neg_quadratic_isLittleO_rpow_atTop ha b s).congr' EventuallyEq.rfl ?_
refine (eventually_gt_atTop 0).mp (Eventually.of_forall fun x hx ↦ ?_)
simp_rw [abs_of_pos hx]
| null |
77f9d951421aa47eea0dc2ddc7290d61d25dd6ce3567636c6ae5496eef517390
| null | null | null | null | null | null | 14
| 10
|
unknown identifier 'sq_neg'
|
simp [sq_neg, neg_mul_neg]
|
a : ℂ ha : a.re < 0 b : ℂ s : ℝ ⊢ (fun x => cexp (a * ↑x ^ 2 + b * ↑x)) =o[cocompact ℝ] fun x => |x| ^ s
|
The proof fails because it uses an undefined identifier 'sq_neg' which isn't available in the current context or imported modules.
|
Replace the undefined 'sq_neg' with the correct lemma 'neg_sq' which properly handles squaring negative numbers.
|
herald
|
lme
|
train
|
List.insertP_loop.lean
|
import Batteries.Control.ForInStep.Lemmas
import Batteries.Data.List.Basic
import Batteries.Tactic.Init
import Batteries.Tactic.Alias
import Batteries.Data.List.Lemmas
open List
open Nat
variable [BEq α]
variable [BEq α]
variable [LawfulBEq α]
theorem theorem_20772 (a : α) (l r : List α) :
insertP.loop p a l r = reverseAux r (insertP p a l) := by
induction l generalizing r with simp [insertP, insertP.loop, cond]
| cons b l ih => rw [ih (b :: r), ih [b]]; split <;> simp
|
import Batteries.Control.ForInStep.Lemmas
import Batteries.Data.List.Basic
import Batteries.Tactic.Init
import Batteries.Tactic.Alias
import Batteries.Data.List.Lemmas
open List
open Nat
variable [BEq α]
variable [BEq α]
variable [LawfulBEq α]
theorem theorem_20772 (a : α) (l r : List α) :
insertP.loop p a l r = reverseAux r (insertP p a l) := by
induction l generalizing r with simp [insertP, insertP.loop, cond]
| nil => rfl | cons h t ih => simp [ih]
| null |
30851a0a1685bdb97bc96501347f17bed8b94b50b1ebaad31c474bba8e4fb5d5
| null | null | null | null | null | null | 11
| 2
|
Alternative 'nil' is not needed
|
| nil => rfl | cons h t ih => simp [ih]
|
α : Type u_1 inst✝² inst✝¹ : BEq α inst✝ : LawfulBEq α p : α → Bool a : α l r : List α ⊢ insertP.loop p a l r = r.reverseAux (insertP p a l)
|
The proof fails because it includes an unnecessary `nil` case in the pattern match when using `induction`, which Lean detects as redundant. The theorem can be proved without explicitly handling the `nil` case.
|
Remove the `nil` case and focus the proof on the `cons` case with proper rewriting and simplification steps.
|
herald
|
lme
|
train
|
Real.logb_div_base.lean
|
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Int.Log
import Mathlib.Analysis.SpecialFunctions.Log.Base
open Real
open Set Filter Function
open Topology
variable {b x y : ℝ}
theorem theorem_15287 {a b : ℝ} (h₁ : a ≠ 0) (h₂ : b ≠ 0) (c : ℝ) :
logb (a / b) c = ((logb a c)⁻¹ - (logb b c)⁻¹)⁻¹ := by
rw [← inv_logb_div_base h₁ h₂ c, inv_inv]
|
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Int.Log
import Mathlib.Analysis.SpecialFunctions.Log.Base
open Real
open Set Filter Function
open Topology
variable {b x y : ℝ}
theorem theorem_15287 {a b : ℝ} (h₁ : a ≠ 0) (h₂ : b ≠ 0) (c : ℝ) :
logb (a / b) c = ((logb a c)⁻¹ - (logb b c)⁻¹)⁻¹ := by
rw [Real.logb, Real.logb, Real.logb, Real.log_div h₁ h₂, one_div_sub_one_div]
| null |
a9ec370ff1740feba8ff8c3b3858e5a861931bdbd8480b37e69772a1cf749a91
| null | null | null | null | null | null | 8
| 56
|
unsolved goals
a b : ℝ
h₁ : a ≠ 0
h₂ : b ≠ 0
c : ℝ
⊢ log c / (log a - log b) = ((log c / log a)⁻¹ - (log c / log b)⁻¹)⁻¹
|
logb (a / b) c = ((logb a c)⁻¹ - (logb b c)⁻¹)⁻¹ := by
|
a b : ℝ h₁ : a ≠ 0 h₂ : b ≠ 0 c : ℝ ⊢ logb (a / b) c = ((logb a c)⁻¹ - (logb b c)⁻¹)⁻¹
|
The proof fails because the rewrite rules used don't properly transform the left-hand side into the right-hand side - logb is expanded but the subsequent division of logs isn't properly simplified to match the goal's structure.
|
Use a lemma that directly relates division inside logb to subtraction of reciprocals instead of trying to expand logb.
|
herald
|
lme
|
train
|
Stream'.tails_eq.lean
|
import Mathlib.Data.Stream.Defs
import Mathlib.Logic.Function.Basic
import Mathlib.Data.List.Basic
import Mathlib.Data.Stream.Init
open Stream'
open Nat Function Option
variable {α : Type u} {β : Type v} {δ : Type w}
variable (f : α → β)
variable (f : α → β → δ)
variable (R : Stream' α → Stream' α → Prop)
theorem theorem_30351 (s : Stream' α) : tails s = tail s::tails (tail s) := by
unfold tails; rw [corec_eq]; rfl
|
import Mathlib.Data.Stream.Defs
import Mathlib.Logic.Function.Basic
import Mathlib.Data.List.Basic
import Mathlib.Data.Stream.Init
open Stream'
open Nat Function Option
variable {α : Type u} {β : Type v} {δ : Type w}
variable (f : α → β)
variable (f : α → β → δ)
variable (R : Stream' α → Stream' α → Prop)
theorem theorem_30351 (s : Stream' α) : tails s = tail s::tails (tail s) := by
ext n; simp [tails]
| null |
48e70b19ea95deb304b8e4cc387dddf95cd73e3217b9e327f16d33091a64913e
| null | null | null | null | null | null | 9
| 76
|
unsolved goals
case a.a
α : Type u
s : Stream' α
n n✝ : ℕ
⊢ ((corec id tail s.tail).get n).get n✝ = ((s.tail :: corec id tail s.tail.tail).get n).get n✝
|
theorem theorem_30351 (s : Stream' α) : tails s = tail s::tails (tail s) := by
|
α : Type u s : Stream' α ⊢ s.tails = s.tail :: s.tail.tails
|
The incorrect proof fails because the `simp [tails]` tactic alone is insufficient to unfold and simplify the `tails` function definition completely. The goal remains unsolved as it requires more precise rewriting of the underlying stream corecursor.
|
Explicitly unfold the `tails` definition and use `corec_eq` to properly rewrite the stream corecursor.
|
herald
|
lme
|
train
|
Equiv.Perm.two_le_card_support_cycleOf_iff.lean
|
import Mathlib.Algebra.Module.BigOperators
import Mathlib.Data.Finset.NoncommProd
import Mathlib.Data.Fintype.Perm
import Mathlib.Data.Int.ModEq
import Mathlib.GroupTheory.Perm.List
import Mathlib.GroupTheory.Perm.Sign
import Mathlib.Logic.Equiv.Fintype
import Mathlib.GroupTheory.Perm.Cycle.Basic
import Mathlib.GroupTheory.Perm.Cycle.Factors
open Equiv
open Perm
open Equiv Function Finset
variable {ι α β : Type*}
variable {f g : Perm α} {x y : α}
theorem theorem_33921 [DecidableEq α] [Fintype α] :
2 ≤ card (cycleOf f x).support ↔ f x ≠ x := by
refine ⟨fun h => ?_, fun h => by simpa using (isCycle_cycleOf _ h).two_le_card_support⟩
contrapose! h
rw [← cycleOf_eq_one_iff] at h
simp [h]
|
import Mathlib.Algebra.Module.BigOperators
import Mathlib.Data.Finset.NoncommProd
import Mathlib.Data.Fintype.Perm
import Mathlib.Data.Int.ModEq
import Mathlib.GroupTheory.Perm.List
import Mathlib.GroupTheory.Perm.Sign
import Mathlib.Logic.Equiv.Fintype
import Mathlib.GroupTheory.Perm.Cycle.Basic
import Mathlib.GroupTheory.Perm.Cycle.Factors
open Equiv
open Perm
open Equiv Function Finset
variable {ι α β : Type*}
variable {f g : Perm α} {x y : α}
theorem theorem_33921 [DecidableEq α] [Fintype α] :
2 ≤ card (cycleOf f x).support ↔ f x ≠ x := by
refine ⟨fun h => ?_, fun h => by simpa using (isCycle_cycleOf _ h).two_le_card_support⟩
by_contra h'
rw [← cycleOf_eq_one_iff] at h
simp [h]
| null |
69b93befd185541b14aba6156003ede85514e9799ac889f8b87d279c1050c31b
| null | null | null | null | null | null | 12
| 6
|
tactic 'rewrite' failed, did not find instance of the pattern in the target expression
?f ?m.3890 = ?m.3890
α : Type u_2
f : Perm α
x : α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
h : 2 ≤ #(f.cycleOf x).support
h' : f x = x
⊢ False
|
rw [← cycleOf_eq_one_iff] at h
|
α : Type u_2 f : Perm α x : α inst✝¹ : DecidableEq α inst✝ : Fintype α h : 2 ≤ #(f.cycleOf x).support h' : f x = x ⊢ False
|
The proof fails because `cycleOf_eq_one_iff` requires `f.cycleOf x = 1` as the rewrite pattern, but `h'` provides `f x = x` instead. The contrapositive approach is incorrect here.
|
Use `contrapose! h` instead of `by_contra h'` to properly negate the inequality and match the required pattern for rewriting.
|
herald
|
lme
|
train
|
LightProfinite.Extend.functorOp_final.lean
|
import Mathlib.Topology.Category.LightProfinite.AsLimit
import Mathlib.Topology.Category.Profinite.Extend
import Mathlib.Topology.Category.LightProfinite.Extend
open LightProfinite
open Extend
open CategoryTheory Limits FintypeCat Functor
variable {F : ℕᵒᵖ ⥤ FintypeCat.{u}} (c : Cone <| F ⋙ toLightProfinite)
theorem theorem_34619 (hc : IsLimit c) [∀ i, Epi (c.π.app i)] : Final (functorOp c) := by
have := functor_initial c hc
have : ((StructuredArrow.toCostructuredArrow toLightProfinite c.pt)).IsEquivalence :=
(inferInstance : (structuredArrowOpEquivalence _ _).functor.IsEquivalence )
have : (functor c).rightOp.Final :=
inferInstanceAs ((opOpEquivalence ℕ).inverse ⋙ (functor c).op).Final
exact Functor.final_comp (functor c).rightOp _
|
import Mathlib.Topology.Category.LightProfinite.AsLimit
import Mathlib.Topology.Category.Profinite.Extend
import Mathlib.Topology.Category.LightProfinite.Extend
open LightProfinite
open Extend
open CategoryTheory Limits FintypeCat Functor
variable {F : ℕᵒᵖ ⥤ FintypeCat.{u}} (c : Cone <| F ⋙ toLightProfinite)
theorem theorem_34619 (hc : IsLimit c) [∀ i, Epi (c.π.app i)] : Final (functorOp c) := by
have := functor_initial c hc
have : ((StructuredArrow.toCostructuredArrow toLightProfinite c.pt)).IsEquivalence :=
(inferInstance : (structuredArrowOpEquivalence _ _).functor.IsEquivalence )
have : ((opOpEquivalence ℕ).inverse ⋙ (functor c).op).Final :=
inferInstanceAs ((opOpEquivalence ℕ).inverse ⋙ (functor c).op).Final
exact Functor.final_comp (functor c).rightOp _
| null |
b58d1bb810a79ed804b1eb8a4811adddf0e35356ba78462cbfdd6bda8369475b
| null | null | null | null | null | null | 13
| 8
|
failed to synthesize
(functor c).rightOp.Final
Hint: Additional diagnostic information may be available using the `set_option diagnostics true` command.
|
exact Functor.final_comp (functor c).rightOp _
|
F : ℕᵒᵖ ⥤ FintypeCat c : Cone (F ⋙ toLightProfinite) hc : IsLimit c inst✝ : ∀ (i : ℕᵒᵖ), Epi (c.π.app i) this✝¹ : (functor c).Initial this✝ : (StructuredArrow.toCostructuredArrow toLightProfinite c.pt).IsEquivalence this : ((opOpEquivalence ℕ).inverse ⋙ (functor c).op).Final ⊢ (functorOp c).Final
|
The proof fails because the instance `(functor c).rightOp.Final` cannot be directly inferred; the code attempts to use `inferInstanceAs` with a different type than what's needed.
|
Change the type annotation to match exactly what needs to be inferred for `(functor c).rightOp.Final`.
|
herald
|
lme
|
train
|
MeasureTheory.hitting_mono.lean
|
import Mathlib.Probability.Process.Stopping
import Mathlib.Tactic.AdaptationNote
import Mathlib.Probability.Process.HittingTime
open MeasureTheory
open Filter Order TopologicalSpace
open scoped Classical MeasureTheory NNReal ENNReal Topology
variable {Ω β ι : Type*} {m : MeasurableSpace Ω}
variable [ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β} {n i : ι} {ω : Ω}
theorem theorem_7271 {m₁ m₂ : ι} (hm : m₁ ≤ m₂) : hitting u s n m₁ ω ≤ hitting u s n m₂ ω := by
by_cases h : ∃ j ∈ Set.Icc n m₁, u j ω ∈ s
· exact (hitting_eq_hitting_of_exists hm h).le
· simp_rw [hitting, if_neg h]
split_ifs with h'
· obtain ⟨j, hj₁, hj₂⟩ := h'
refine le_csInf ⟨j, hj₁, hj₂⟩ ?_
by_contra hneg; push_neg at hneg
obtain ⟨i, hi₁, hi₂⟩ := hneg
exact h ⟨i, ⟨hi₁.1.1, hi₂.le⟩, hi₁.2⟩
· exact hm
|
import Mathlib.Probability.Process.Stopping
import Mathlib.Tactic.AdaptationNote
import Mathlib.Probability.Process.HittingTime
open MeasureTheory
open Filter Order TopologicalSpace
open scoped Classical MeasureTheory NNReal ENNReal Topology
variable {Ω β ι : Type*} {m : MeasurableSpace Ω}
variable [ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β} {n i : ι} {ω : Ω}
theorem theorem_7271 {m₁ m₂ : ι} (hm : m₁ ≤ m₂) : hitting u s n m₁ ω ≤ hitting u s n m₂ ω := by
by_cases h : ∃ j ∈ Set.Icc n m₁, u j ω ∈ s
· exact le_csInf (by simp [h]) (by intro b hb; exact csInf_le hb)
· simp_rw [hitting, if_neg h]
split_ifs with h'
· obtain ⟨j, hj₁, hj₂⟩ := h'
refine le_csInf ⟨j, hj₁, hj₂⟩ ?_
by_contra hneg; push_neg at hneg
obtain ⟨i, hi₁, hi₂⟩ := hneg
exact h ⟨i, ⟨hi₁.1.1, hi₂.le⟩, hi₁.2⟩
· exact hm
| null |
b2d1f3e6b9b2a0f354f312edfbf5565041b239417726cb5b7988d960274296c3
| null | null | null | null | null | null | 10
| 23
|
simp made no progress
|
· exact le_csInf (by simp [h]) (by intro b hb; exact csInf_le hb)
|
Ω : Type u_1 β : Type u_2 ι : Type u_3 inst✝ : ConditionallyCompleteLinearOrder ι u : ι → Ω → β s : Set β n : ι ω : Ω m₁ m₂ : ι hm : m₁ ≤ m₂ h : ∃ j ∈ Set.Icc n m₁, u j ω ∈ s ⊢ Set.Nonempty ?m.1364
|
The proof fails because during the first case where h is true, the proof attempts to use simp for a non-trivial statement about nonempty sets, which simp cannot solve automatically.
|
Replace the manual proof attempt with the specialized lemma hitting_eq_hitting_of_exists which directly handles this case.
|
herald
|
lme
|
train
|
String.prev_lt_of_pos.lean
|
import Init.Data.List.Basic
import Init.Data.Char.Basic
import Init.Data.Option.Basic
import Init.Data.String.Basic
open String
theorem theorem_38179 (s : String) (i : Pos) (h : i ≠ 0) : (s.prev i).1 < i.1 := by
simp [prev, h]
exact utf8PrevAux_lt_of_pos _ _ _ h
|
import Init.Data.List.Basic
import Init.Data.Char.Basic
import Init.Data.Option.Basic
import Init.Data.String.Basic
open String
theorem theorem_38179 (s : String) (i : Pos) (h : i ≠ 0) : (s.prev i).1 < i.1 := by
dsimp [String.prev]
exact utf8PrevAux_lt_of_pos _ _ _ h
| null |
2fe643ef23a94dc74f62ce1bb8af72553582016e9ef8a904abf7429ed14b42d7
| null | null | null | null | null | null | 6
| 2
|
type mismatch
utf8PrevAux_lt_of_pos ?m.84 ?m.85 i h
has type
(utf8PrevAux ?m.84 ?m.85 i).byteIdx < i.byteIdx : Prop
but is expected to have type
(if i = 0 then 0 else utf8PrevAux s.data 0 i).byteIdx < i.byteIdx : Prop
|
exact utf8PrevAux_lt_of_pos _ _ _ h
|
s : String i : Pos h : i ≠ 0 ⊢ (if i = 0 then 0 else utf8PrevAux s.data 0 i).byteIdx < i.byteIdx
|
The proof fails because the `dsimp` tactic only partially simplifies the expression, leaving the `if` condition unresolved, while `utf8PrevAux_lt_of_pos` expects the fully simplified form without the conditional.
|
Use `simp` with the `prev` lemma and the hypothesis `h` to fully simplify the expression before applying `utf8PrevAux_lt_of_pos`.
|
herald
|
lme
|
train
|
Tuple.sort_eq_refl_iff_monotone.lean
|
import Mathlib.Data.Finset.Sort
import Mathlib.Data.List.FinRange
import Mathlib.Data.Prod.Lex
import Mathlib.GroupTheory.Perm.Basic
import Mathlib.Order.Interval.Finset.Fin
import Mathlib.Data.Fin.Tuple.Sort
open Tuple
variable {n : ℕ}
variable {α : Type*} [LinearOrder α]
variable {α : Type*} [LinearOrder α]
open List
variable {n : ℕ} {α : Type*}
variable [LinearOrder α] {f : Fin n → α} {σ : Equiv.Perm (Fin n)}
theorem theorem_30399 : sort f = Equiv.refl _ ↔ Monotone f := by
rw [eq_comm, eq_sort_iff, Equiv.coe_refl, Function.comp_id]
simp only [id, and_iff_left_iff_imp]
exact fun _ _ _ hij _ => hij
|
import Mathlib.Data.Finset.Sort
import Mathlib.Data.List.FinRange
import Mathlib.Data.Prod.Lex
import Mathlib.GroupTheory.Perm.Basic
import Mathlib.Order.Interval.Finset.Fin
import Mathlib.Data.Fin.Tuple.Sort
open Tuple
variable {n : ℕ}
variable {α : Type*} [LinearOrder α]
variable {α : Type*} [LinearOrder α]
open List
variable {n : ℕ} {α : Type*}
variable [LinearOrder α] {f : Fin n → α} {σ : Equiv.Perm (Fin n)}
theorem theorem_30399 : sort f = Equiv.refl _ ↔ Monotone f := by
constructor
simp only [id, and_iff_left_iff_imp]
exact fun _ _ _ hij _ => hij
| null |
fac5869507d15fb1bfec49d20299cd117275b52a1af39893a9d862784d1dc0f6
| null | null | null | null | null | null | 12
| 2
|
simp made no progress
|
simp only [id, and_iff_left_iff_imp]
|
case mp n : ℕ α : Type u_3 inst✝ : LinearOrder α f : Fin n → α ⊢ sort f = Equiv.refl (Fin n) → Monotone f case mpr n : ℕ α : Type u_3 inst✝ : LinearOrder α f : Fin n → α ⊢ Monotone f → sort f = Equiv.refl (Fin n)
|
The proof fails because the initial approach using `simp only` doesn't make progress on simplifying the goal, as indicated by Lean's error message.
|
Use more specific rewriting steps like `eq_comm` and `eq_sort_iff` before applying the simplifier, as shown in the corrected proof.
|
herald
|
lme
|
train
|
Filter.IsBoundedUnder.bddAbove_range_of_cofinite.lean
|
import Mathlib.Order.Filter.Cofinite
import Mathlib.Order.Hom.CompleteLattice
import Mathlib.Order.LiminfLimsup
open Filter
open IsBoundedUnder
open Filter Set Function
variable {α β γ ι ι' : Type*}
variable {r : α → α → Prop} {f g : Filter α}
variable [Preorder α] {f : Filter β} {u : β → α} {s : Set β}
theorem theorem_20359 [Preorder β] [IsDirected β (· ≤ ·)] {f : α → β}
(hf : IsBoundedUnder (· ≤ ·) cofinite f) : BddAbove (range f) := by
rcases hf with ⟨b, hb⟩
haveI : Nonempty β := ⟨b⟩
rw [← image_univ, ← union_compl_self { x | f x ≤ b }, image_union, bddAbove_union]
exact ⟨⟨b, forall_mem_image.2 fun x => id⟩, (hb.image f).bddAbove⟩
|
import Mathlib.Order.Filter.Cofinite
import Mathlib.Order.Hom.CompleteLattice
import Mathlib.Order.LiminfLimsup
open Filter
open IsBoundedUnder
open Filter Set Function
variable {α β γ ι ι' : Type*}
variable {r : α → α → Prop} {f g : Filter α}
variable [Preorder α] {f : Filter β} {u : β → α} {s : Set β}
theorem theorem_20359 [Preorder β] [IsDirected β (· ≤ ·)] {f : α → β}
(hf : IsBoundedUnder (· ≤ ·) cofinite f) : BddAbove (range f) := by
rcases hf with ⟨b, hb⟩
haveI : Nonempty β := ⟨b⟩
have h_fin : Set.Finite {x | ¬ f x ≤ b} := (Filter.eventually_cofinite.1 hb)
exact ⟨⟨b, forall_mem_image.2 fun x => id⟩, (hb.image f).bddAbove⟩
| null |
73ee00d4871572c24ac262a1d73fa4c6214b552a30a784a6e386b9f41d58202a
| null | null | null | null | null | null | 14
| 9
|
invalid constructor ⟨...⟩, expected type must be an inductive type
β
|
exact ⟨⟨b, forall_mem_image.2 fun x => id⟩, (hb.image f).bddAbove⟩
|
case intro α : Type u_1 β : Type u_2 inst✝² : Preorder α inst✝¹ : Preorder β inst✝ : IsDirected β fun x1 x2 => x1 ≤ x2 f : α → β b : β hb : ∀ᶠ (x : β) in map f cofinite, (fun x1 x2 => x1 ≤ x2) x b this : Nonempty β h_fin : {x | ¬f x ≤ b}.Finite ⊢ BddAbove (range f)
|
The proof fails because it tries to construct a term of type `BddAbove (range f)` using a pair `⟨...⟩` where `BddAbove` is a property, not an inductive type. The initial attempt incorrectly assumes `BddAbove` has a constructor.
|
Use `bddAbove_union` to combine boundedness results for the image of `f` under cofinite elements and its complement.
|
herald
|
lme
|
train
|
MvPolynomial.decomposition.decompose'_eq.lean
|
import Mathlib.Algebra.DirectSum.Internal
import Mathlib.Algebra.GradedMonoid
import Mathlib.Algebra.MvPolynomial.CommRing
import Mathlib.Algebra.MvPolynomial.Equiv
import Mathlib.Algebra.MvPolynomial.Variables
import Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous
import Mathlib.Algebra.Polynomial.Roots
import Mathlib.RingTheory.MvPolynomial.Homogeneous
open MvPolynomial
open decomposition
variable {σ : Type*} {τ : Type*} {R : Type*} {S : Type*}
open Finsupp
variable [CommSemiring R]
variable (σ R)
variable {σ R}
variable (σ R)
variable {σ R}
variable (σ)
variable (R)
variable {σ}
variable [CommSemiring S] {φ ψ : MvPolynomial σ R} {m n : ℕ}
variable {R σ : Type*} [CommRing R] {φ ψ : MvPolynomial σ R} {n : ℕ}
open Polynomial in
variable {R σ : Type*} [CommRing R] [IsDomain R] {F G : MvPolynomial σ R} {n : ℕ}
open Cardinal Polynomial
open Finset
open Finset Finsupp
variable (n : ℕ) (φ ψ : MvPolynomial σ R)
theorem theorem_32839 :
decomposition.decompose' = fun φ : MvPolynomial σ R =>
DirectSum.mk (fun i : ℕ => ↥(homogeneousSubmodule σ R i)) (φ.support.image Finsupp.degree)
fun m => ⟨homogeneousComponent m φ, homogeneousComponent_mem m φ⟩ := by
rw [degree_eq_weight_one]
rfl
|
import Mathlib.Algebra.DirectSum.Internal
import Mathlib.Algebra.GradedMonoid
import Mathlib.Algebra.MvPolynomial.CommRing
import Mathlib.Algebra.MvPolynomial.Equiv
import Mathlib.Algebra.MvPolynomial.Variables
import Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous
import Mathlib.Algebra.Polynomial.Roots
import Mathlib.RingTheory.MvPolynomial.Homogeneous
open MvPolynomial
open decomposition
variable {σ : Type*} {τ : Type*} {R : Type*} {S : Type*}
open Finsupp
variable [CommSemiring R]
variable (σ R)
variable {σ R}
variable (σ R)
variable {σ R}
variable (σ)
variable (R)
variable {σ}
variable [CommSemiring S] {φ ψ : MvPolynomial σ R} {m n : ℕ}
variable {R σ : Type*} [CommRing R] {φ ψ : MvPolynomial σ R} {n : ℕ}
open Polynomial in
variable {R σ : Type*} [CommRing R] [IsDomain R] {F G : MvPolynomial σ R} {n : ℕ}
open Cardinal Polynomial
open Finset
open Finset Finsupp
variable (n : ℕ) (φ ψ : MvPolynomial σ R)
theorem theorem_32839 :
decomposition.decompose' = fun φ : MvPolynomial σ R =>
DirectSum.mk (fun i : ℕ => ↥(homogeneousSubmodule σ R i)) (φ.support.image Finsupp.degree)
fun m => ⟨homogeneousComponent m φ, homogeneousComponent_mem m φ⟩ := by
ext φ
rfl
| null |
2a8116e7949d4fcbd209e77274132e46ad1eac8c97c91bbfe7a1fe92f8ee0cf3
| null | null | null | null | null | null | 28
| 2
|
tactic 'rfl' failed, the left-hand side
MvPolynomial.coeff m✝ ↑((DirectSum.Decomposition.decompose' φ) i✝)
is not definitionally equal to the right-hand side
MvPolynomial.coeff m✝
↑(((DirectSum.mk (fun i => ↥(homogeneousSubmodule σ R i)) (image Finsupp.degree φ.support)) fun m =>
⟨(homogeneousComponent ↑m) φ, ⋯⟩)
i✝)
case h.w.a.a
R : Type u_5
σ : Type u_6
inst✝ : CommRing R
φ : MvPolynomial σ R
i✝ : ℕ
m✝ : σ →₀ ℕ
⊢ MvPolynomial.coeff m✝ ↑((DirectSum.Decomposition.decompose' φ) i✝) =
MvPolynomial.coeff m✝
↑(((DirectSum.mk (fun i => ↥(homogeneousSubmodule σ R i)) (image Finsupp.degree φ.support)) fun m =>
⟨(homogeneousComponent ↑m) φ, ⋯⟩)
i✝)
|
rfl
|
case h.w.a.a R : Type u_5 σ : Type u_6 inst✝ : CommRing R φ : MvPolynomial σ R i✝ : ℕ m✝ : σ →₀ ℕ ⊢ MvPolynomial.coeff m✝ ↑((DirectSum.Decomposition.decompose' φ) i✝) = MvPolynomial.coeff m✝ ↑(((DirectSum.mk (fun i => ↥(homogeneousSubmodule σ R i)) (image Finsupp.degree φ.support)) fun m => ⟨(homogeneousComponent ↑m) φ, ⋯⟩) i✝)
|
The proof fails because `rfl` cannot show definitional equality between the two sides of the equation, which suggests they are equal only propositionally. The decomposition functions are implemented differently at the definition level.
|
Use functional extensionality and the properties of `decompose'` to show equality rather than relying on definitional equality.
|
herald
|
lme
|
train
|
Filter.mem_coclosed_compact'.lean
|
import Mathlib.Order.Filter.Basic
import Mathlib.Topology.Bases
import Mathlib.Data.Set.Accumulate
import Mathlib.Topology.Bornology.Basic
import Mathlib.Topology.LocallyFinite
import Mathlib.Topology.Compactness.Compact
open Filter
open Set Filter Topology TopologicalSpace Function
variable {X : Type u} {Y : Type v} {ι : Type*}
variable [TopologicalSpace X] [TopologicalSpace Y] {s t : Set X}
variable [TopologicalSpace X] [TopologicalSpace Y] {s t : Set X}
theorem theorem_2947 : s ∈ coclosedCompact X ↔ ∃ t, IsClosed t ∧ IsCompact t ∧ sᶜ ⊆ t := by
simp only [hasBasis_coclosedCompact.mem_iff, compl_subset_comm, and_assoc]
|
import Mathlib.Order.Filter.Basic
import Mathlib.Topology.Bases
import Mathlib.Data.Set.Accumulate
import Mathlib.Topology.Bornology.Basic
import Mathlib.Topology.LocallyFinite
import Mathlib.Topology.Compactness.Compact
open Filter
open Set Filter Topology TopologicalSpace Function
variable {X : Type u} {Y : Type v} {ι : Type*}
variable [TopologicalSpace X] [TopologicalSpace Y] {s t : Set X}
variable [TopologicalSpace X] [TopologicalSpace Y] {s t : Set X}
theorem theorem_2947 : s ∈ coclosedCompact X ↔ ∃ t, IsClosed t ∧ IsCompact t ∧ sᶜ ⊆ t := by
simp_rw [mem_coclosedCompact, compl_subset_comm]
| null |
02836a3670735fc6aeed6640de7a7c9bf2aa925aca9a02c9ceec8cffe3ca8ec2
| null | null | null | null | null | null | 9
| 11
|
unknown identifier 'mem_coclosedCompact'
|
simp_rw [mem_coclosedCompact, compl_subset_comm]
|
X : Type u inst✝¹ inst✝ : TopologicalSpace X s : Set X ⊢ s ∈ coclosedCompact X ↔ ∃ t, IsClosed t ∧ IsCompact t ∧ sᶜ ⊆ t
|
The proof fails because it references an undefined identifier 'mem_coclosedCompact' which is not part of the available imports or context.
|
Use the correct lemma 'hasBasis_coclosedCompact.mem_iff' instead of the non-existent 'mem_coclosedCompact'.
|
herald
|
lme
|
train
|
End of preview.
APRIL Dataset
Dataset Description
The APRIL dataset contains 258,103 examples of Lean 4 proof errors and corrections, organized by error type and split. Each example includes a correct proof, an incorrect proof that produces a specific error, and detailed metadata about the error.
Data Splits
| Split | Total Examples |
|---|---|
| Train | 249,005 (96.5%) |
| Val | 9,263 (3.6%) |
| Test | 1,835 (0.7%) |
Error Types
The dataset categorizes errors into four types:
THME (Theorem Mutation Error) - 154,869 examples (60.0%)
- Errors produced by changing one theorem to a similar theorem
TME (Tactic Mutation Error) - 62,129 examples (24.1%)
- Errors produced by changing one to three tactics to similar tactics
LME (Line Mutation Error) - 18,319 examples (7.1%)
- Errors produced by having Deepseek rewrite a single line of the proof
MLME (Multi-Line Mutation Error) - 22,786 examples (8.8%)
- Errors Produced by having Deepseek rewrite the last chunk of the proof (less than half of the lines)
File Organization
train/
├── thme_train.jsonl (148,361 examples, 1.3 GB)
├── tme_train.jsonl (59,667 examples, 265 MB)
├── mlme_train.jsonl (23,879 examples, 81 MB)
└── lme_train.jsonl (17,098 examples, 57 MB)
val/
├── thme_val.jsonl (5,415 examples, 49 MB)
├── tme_val.jsonl (2,064 examples, 9.1 MB)
├── mlme_val.jsonl (763 examples, 2.7 MB)
└── lme_val.jsonl (1,021 examples, 3.5 MB)
test/
├── thme_test.jsonl (1,093 examples, 9.0 MB)
├── tme_test.jsonl (398 examples, 1.7 MB)
├── mlme_test.jsonl (144 examples, 482 KB)
└── lme_test.jsonl (200 examples, 697 KB)
Data Fields
Common fields (all error types):
correct_proof: The complete, working Lean 4 proof (includes imports and context)incorrect_proof: The modified proof that produces an errorsrc_hash: Hash of the source theoremline: Line number where the error occurscol: Column number where the error occurserror: The Lean compiler error messageline_at_error: The specific line of code that caused the errorstate_at_error: The proof state when the error occurredexplanation: Natural language explanation of why the proof failsfix_suggestion: Natural language suggestion for fixing the errorsource: Data source (e.g., "herald")error_type: One oflme,tme,mlme, orthmesplit: One oftrain,val, ortesttheorem: Theorem identifier (may be null) (used for theorem mutations only)correct_name: Name of the correct theorem/lemma (may be null) (used for theorem mutations only)incorrect_name: Name of the incorrect theorem/lemma used (may be null) (used for theorem mutations only)correct_formal: Formal statement of the correct theorem (may be null) (used for theorem mutations only)incorrect_formal: Formal statement of the incorrect theorem (may be null) (used for theorem mutations only)correct_informal: Informal description of the correct theorem (may be null) (used for theorem mutations only)incorrect_informal: Informal description of the incorrect theorem (may be null) (used for theorem mutations only)
Download Options
- Individual files by split and error type - Download only what you need
- Complete archive:
data_by_split.zip(273 MB compressed, ~1.8 GB uncompressed)
Example Entry (LME)
{
"path": "CategoryTheory.Bicategory.id_whiskerLeft_symm.lean",
"correct_proof": "import Mathlib.CategoryTheory.NatIso\nimport Mathlib.CategoryTheory.Bicategory.Basic\n\nopen CategoryTheory\nopen Bicategory\nopen Category Iso\nvariable {B : Type u} [Bicategory.{w, v} B] {a b c d e : B}\n\ntheorem theorem_28010 {f g : a ⟶ b} (η : f ⟶ g) : η = (λ_ f).inv ≫ 𝟙 a ◁ η ≫ (λ_ g).hom := by\n simp",
"incorrect_proof": "import Mathlib.CategoryTheory.NatIso\nimport Mathlib.CategoryTheory.Bicategory.Basic\n\nopen CategoryTheory\nopen Bicategory\nopen Category Iso\nvariable {B : Type u} [Bicategory.{w, v} B] {a b c d e : B}\n\ntheorem theorem_28010 {f g : a ⟶ b} (η : f ⟶ g) : η = (λ_ f).inv ≫ 𝟙 a ◁ η ≫ (λ_ g).hom := by\n rw [← Iso.inv_comp_eq, leftUnitor_naturality, Category.assoc]",
"theorem": null,
"src_hash": "25ba40f63317e3a83081a8d23cd8f635e281bac38cb2c2548dc0bcecd9660e64",
"correct_name": null,
"incorrect_name": null,
"correct_formal": null,
"incorrect_formal": null,
"correct_informal": null,
"incorrect_informal": null,
"line": 8,
"col": 6,
"error": "tactic 'rewrite' failed, did not find instance of the pattern in the target expression\n ?f = hom ?α ≫ ?g\nB : Type u\ninst✝ : Bicategory B\na b : B\nf g : a ⟶ b\nη : f ⟶ g\n⊢ η = (λ_ f).inv ≫ 𝟙 a ◁ η ≫ (λ_ g).hom",
"line_at_error": "rw [← Iso.inv_comp_eq, leftUnitor_naturality, Category.assoc]",
"state_at_error": "B : Type u inst✝ : Bicategory B a b : B f g : a ⟶ b η : f ⟶ g ⊢ η = (λ_ f).inv ≫ 𝟙 a ◁ η ≫ (λ_ g).hom",
"explanation": "The proof fails because the rewrite tactic cannot match the pattern `?f = hom ?α ≫ ?g` in the target expression, as the target is not in the expected form for `Iso.inv_comp_eq` to apply directly.",
"fix_suggestion": "Use the `simp` tactic which can automatically handle all necessary rewrites and simplifications for this bicategorical identity.",
"source": "herald",
"error_type": "lme",
"split": "train"
}
Citation
If you use this dataset in your research, please cite:
@article{april2026,
title = {Learning to Repair Lean Proofs from Compiler Feedback},
author = {Wang, Yiran and Chess, Simon and Lee, Daniel and Ge, Siyuan and Mallavarapu, Ajit and Ilin, Vasily},
journal = {arXiv preprint},
year = {2026},
}
License
This dataset is licensed under the Apache License 2.0.
Contact
For questions or issues, please contact Vasily Ilin (https://vilin97.github.io/).
- Downloads last month
- 9