ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Set.univ_sigma_preimage_mk
File: Mathlib/Data/Set/Sigma.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β : ι → Type u_4
s✝ s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i j : ι
a : α i
s : Set ((i : ι) × α i)
⊢ ∀ (x : (i : ι) × α i), (x ∈ univ.sigma fun i => Sigma.mk i ⁻¹' s) ↔ x ∈ s
state_after: no goals
tactic: simp
Theorem: tendsto_inv_nhdsWithin_Iio
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝⁶ : TopologicalSpace G
inst✝⁵ : Group G
inst✝⁴ : TopologicalGroup G
inst✝³ : TopologicalSpace α
f : α → G
s : Set α
x : α
inst✝² : TopologicalSpace H
inst✝¹ : OrderedCommGroup H
inst✝ : ContinuousInv H
a : H
⊢ Tendsto (fun a => a⁻¹) (𝓟 (Iio a)) (𝓟 (Ioi a⁻¹))
state_after: no goals
tactic: simp [tendsto_principal_principal]
Theorem: CategoryTheory.ε_inv_naturality
File: Mathlib/CategoryTheory/Monoidal/End.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
X Y : C
f : X ⟶ Y
⊢ F.εIso.inv.app X ≫ (𝟙_ (C ⥤ C)).map f = F.εIso.inv.app X ≫ f
state_after: no goals
tactic: aesop_cat
Theorem: LinearEquiv.det_symm_mul_det
File: Mathlib/LinearAlgebra/Determinant.lean

Proof steps:
state_before: R : Type u_1
inst✝⁸ : CommRing R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
M' : Type u_3
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
ι : Type u_4
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
e : Basis ι R M
A : Type u_5
inst✝¹ : CommRing A
inst✝ : Module A M
f : M ≃ₗ[A] M
⊢ LinearMap.det ↑f.symm * LinearMap.det ↑f = 1
state_after: no goals
tactic: simp [← LinearMap.det_comp]
Theorem: CategoryTheory.Subobject.le_sInf
File: Mathlib/CategoryTheory/Subobject/Lattice.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : WellPowered C
inst✝ : HasWidePullbacks C
A : C
s : Set (Subobject A)
f : Subobject A
k : ∀ g ∈ s, f ≤ g
⊢ f ≤ sInf s
state_after: case f
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : WellPowered C
inst✝ : HasWidePullbacks C
A : C
s : Set (Subobject A)
f : Subobject A
k : ∀ g ∈ s, f ≤ g
⊢ underlying.obj f ⟶ underlying.obj (sInf s)

case w
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : WellPowered C
inst✝ : HasWidePullbacks C
A : C
s : Set (Subobject A)
f : Subobject A
k : ∀ g ∈ s, f ≤ g
⊢ ?f ≫ (sInf s).arrow = f.arrow
tactic: fapply le_of_comm
Theorem: mem_posTangentConeAt_of_frequently_mem
File: Mathlib/Analysis/Calculus/LocalExtr/Basic.lean

Proof steps:
state_before: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
f' : E →L[ℝ] ℝ
s : Set E
a x y : E
h : ∃ᶠ (t : ℝ) in 𝓝[>] 0, x + t • y ∈ s
⊢ y ∈ posTangentConeAt s x
state_after: case intro.intro
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
f' : E →L[ℝ] ℝ
s : Set E
a✝ x y : E
h : ∃ᶠ (t : ℝ) in 𝓝[>] 0, x + t • y ∈ s
a : ℕ → ℝ
ha : Tendsto a atTop (𝓝[>] 0)
has : ∀ (n : ℕ), x + a n • y ∈ s
⊢ y ∈ posTangentConeAt s x
tactic: obtain ⟨a, ha, has⟩ := Filter.exists_seq_forall_of_frequently h
state_before: case intro.intro
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
f' : E →L[ℝ] ℝ
s : Set E
a✝ x y : E
h : ∃ᶠ (t : ℝ) in 𝓝[>] 0, x + t • y ∈ s
a : ℕ → ℝ
ha : Tendsto a atTop (𝓝[>] 0)
has : ∀ (n : ℕ), x + a n • y ∈ s
⊢ Tendsto (fun n => a⁻¹ n • (fun x => a x • y) n) atTop (𝓝 y)
state_after: case intro.intro
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
f' : E →L[ℝ] ℝ
s : Set E
a✝ x y : E
h : ∃ᶠ (t : ℝ) in 𝓝[>] 0, x + t • y ∈ s
a : ℕ → ℝ
ha : Tendsto a atTop (𝓝[>] 0)
has : ∀ (n : ℕ), x + a n • y ∈ s
⊢ (fun x => y) =ᶠ[atTop] fun n => a⁻¹ n • (fun x => a x • y) n
tactic: refine tendsto_const_nhds.congr' ?_
state_before: case intro.intro
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
f' : E →L[ℝ] ℝ
s : Set E
a✝ x y : E
h : ∃ᶠ (t : ℝ) in 𝓝[>] 0, x + t • y ∈ s
a : ℕ → ℝ
ha : Tendsto a atTop (𝓝[>] 0)
has : ∀ (n : ℕ), x + a n • y ∈ s
⊢ (fun x => y) =ᶠ[atTop] fun n => a⁻¹ n • (fun x => a x • y) n
state_after: case h
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
f' : E →L[ℝ] ℝ
s : Set E
a✝ x y : E
h : ∃ᶠ (t : ℝ) in 𝓝[>] 0, x + t • y ∈ s
a : ℕ → ℝ
ha : Tendsto a atTop (𝓝[>] 0)
has : ∀ (n : ℕ), x + a n • y ∈ s
n : ℕ
hn : 0 < a n
⊢ y = a⁻¹ n • a n • y
tactic: filter_upwards [(tendsto_nhdsWithin_iff.1 ha).2] with n (hn : 0 < a n)
state_before: case h
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
f' : E →L[ℝ] ℝ
s : Set E
a✝ x y : E
h : ∃ᶠ (t : ℝ) in 𝓝[>] 0, x + t • y ∈ s
a : ℕ → ℝ
ha : Tendsto a atTop (𝓝[>] 0)
has : ∀ (n : ℕ), x + a n • y ∈ s
n : ℕ
hn : 0 < a n
⊢ y = a⁻¹ n • a n • y
state_after: no goals
tactic: simp [ne_of_gt hn]
Theorem: Nat.card_le_card_of_injective
File: Mathlib/SetTheory/Cardinal/Finite.lean

Proof steps:
state_before: α✝ : Type u_1
β✝ : Type u_2
α : Type u
β : Type v
inst✝ : Finite β
f : α → β
hf : Injective f
⊢ Nat.card α ≤ Nat.card β
state_after: no goals
tactic: simpa using toNat_le_toNat (lift_mk_le_lift_mk_of_injective hf) (by simp [lt_aleph0_of_finite])
Theorem: Finset.prod_subset_one_on_sdiff
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
h : s₁ ⊆ s₂
hg : ∀ x ∈ s₂ \ s₁, g x = 1
hfg : ∀ x ∈ s₁, f x = g x
⊢ ∏ i ∈ s₁, f i = ∏ i ∈ s₂, g i
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
h : s₁ ⊆ s₂
hg : ∀ x ∈ s₂ \ s₁, g x = 1
hfg : ∀ x ∈ s₁, f x = g x
⊢ ∏ i ∈ s₁, f i = ∏ x ∈ s₁, g x
tactic: rw [← prod_sdiff h, prod_eq_one hg, one_mul]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
h : s₁ ⊆ s₂
hg : ∀ x ∈ s₂ \ s₁, g x = 1
hfg : ∀ x ∈ s₁, f x = g x
⊢ ∏ i ∈ s₁, f i = ∏ x ∈ s₁, g x
state_after: no goals
tactic: exact prod_congr rfl hfg
Theorem: Finset.prod_dite_eq'
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a✝ : α
f g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
a : α
b : (x : α) → x = a → β
⊢ (∏ x ∈ s, if h : x = a then b x h else 1) = if a ∈ s then b a ⋯ else 1
state_after: case pos
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a✝ : α
f g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
a : α
b : (x : α) → x = a → β
h : a ∈ s
⊢ (∏ x ∈ s, if h : x = a then b x h else 1) = b a ⋯

case neg
ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a✝ : α
f g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
a : α
b : (x : α) → x = a → β
h : a ∉ s
⊢ (∏ x ∈ s, if h : x = a then b x h else 1) = 1
tactic: split_ifs with h
Theorem: PrimeSpectrum.image_comap_zeroLocus_eq_zeroLocus_comap
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
hf : Surjective ⇑f
I : Ideal S
⊢ ⇑(comap f) '' zeroLocus ↑I = zeroLocus ↑(Ideal.comap f I)
state_after: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
hf : Surjective ⇑f
I : Ideal S
⊢ ∀ (x : PrimeSpectrum R), (∃ x_1, I ≤ x_1.asIdeal ∧ (comap f) x_1 = x) ↔ Ideal.comap f I ≤ x.asIdeal
tactic: simp only [Set.ext_iff, Set.mem_image, mem_zeroLocus, SetLike.coe_subset_coe]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
hf : Surjective ⇑f
I : Ideal S
⊢ ∀ (x : PrimeSpectrum R), (∃ x_1, I ≤ x_1.asIdeal ∧ (comap f) x_1 = x) ↔ Ideal.comap f I ≤ x.asIdeal
state_after: case refine_1
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
hf : Surjective ⇑f
I : Ideal S
p : PrimeSpectrum R
⊢ (∃ x, I ≤ x.asIdeal ∧ (comap f) x = p) → Ideal.comap f I ≤ p.asIdeal

case refine_2
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R →+* S
hf : Surjective ⇑f
I : Ideal S
p : PrimeSpectrum R
h_I_p : Ideal.comap f I ≤ p.asIdeal
⊢ ∃ x, I ≤ x.asIdeal ∧ (comap f) x = p
tactic: refine fun p => ⟨?_, fun h_I_p => ?_⟩
Theorem: IsPreconnected.preimage_of_isClosedMap
File: Mathlib/Topology/Connected/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : TopologicalSpace α
s✝ t u✝ v✝ : Set α
inst✝ : TopologicalSpace β
s : Set β
hs : IsPreconnected s
f : α → β
hinj : Injective f
hf : IsClosedMap f
hsf : s ⊆ range f
u v : Set α
hu : IsClosed u
hv : IsClosed v
hsuv : f ⁻¹' s ⊆ u ∪ v
hsu : (f ⁻¹' s ∩ u).Nonempty
hsv : (f ⁻¹' s ∩ v).Nonempty
⊢ (f ⁻¹' s ∩ (u ∩ v)).Nonempty
state_after: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : TopologicalSpace α
s✝ t u✝ v✝ : Set α
inst✝ : TopologicalSpace β
s : Set β
hs : IsPreconnected s
f : α → β
hinj : Injective f
hf : IsClosedMap f
u v : Set α
hu : IsClosed u
hv : IsClosed v
hsuv : f ⁻¹' s ⊆ u ∪ v
hsu : (f ⁻¹' s ∩ u).Nonempty
hsv : (f ⁻¹' s ∩ v).Nonempty
hsf : f '' (f ⁻¹' s) = s
⊢ (f ⁻¹' s ∩ (u ∩ v)).Nonempty
tactic: replace hsf : f '' (f ⁻¹' s) = s := image_preimage_eq_of_subset hsf
Theorem: Polynomial.eta
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q f : R[X]
⊢ { toFinsupp := f.toFinsupp } = f
state_after: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
toFinsupp✝ : R[ℕ]
⊢ { toFinsupp := { toFinsupp := toFinsupp✝ }.toFinsupp } = { toFinsupp := toFinsupp✝ }
tactic: cases f
state_before: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
toFinsupp✝ : R[ℕ]
⊢ { toFinsupp := { toFinsupp := toFinsupp✝ }.toFinsupp } = { toFinsupp := toFinsupp✝ }
state_after: no goals
tactic: rfl
Theorem: AlgebraicTopology.inclusionOfMooreComplexMap_f
File: Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{?u.68862, u_1} C
inst✝² : Preadditive C
A : Type u_2
inst✝¹ : Category.{u_3, u_2} A
inst✝ : Abelian A
X : SimplicialObject A
n : ℕ
⊢ (inclusionOfMooreComplexMap X).f n = (NormalizedMooreComplex.objX X n).arrow
state_after: C : Type u_1
inst✝³ : Category.{?u.68862, u_1} C
inst✝² : Preadditive C
A : Type u_2
inst✝¹ : Category.{u_3, u_2} A
inst✝ : Abelian A
X : SimplicialObject A
n : ℕ
⊢ (id
          (ChainComplex.ofHom (fun n => underlying.obj (NormalizedMooreComplex.objX X n))
            (NormalizedMooreComplex.objD X) ⋯ (fun n => X _[n]) (AlternatingFaceMapComplex.objD X) ⋯
            (fun n => (NormalizedMooreComplex.objX X n).arrow) ⋯)).f
      n =
    (NormalizedMooreComplex.objX X n).arrow
tactic: dsimp only [inclusionOfMooreComplexMap]
state_before: C : Type u_1
inst✝³ : Category.{?u.68862, u_1} C
inst✝² : Preadditive C
A : Type u_2
inst✝¹ : Category.{u_3, u_2} A
inst✝ : Abelian A
X : SimplicialObject A
n : ℕ
⊢ (id
          (ChainComplex.ofHom (fun n => underlying.obj (NormalizedMooreComplex.objX X n))
            (NormalizedMooreComplex.objD X) ⋯ (fun n => X _[n]) (AlternatingFaceMapComplex.objD X) ⋯
            (fun n => (NormalizedMooreComplex.objX X n).arrow) ⋯)).f
      n =
    (NormalizedMooreComplex.objX X n).arrow
state_after: no goals
tactic: exact ChainComplex.ofHom_f _ _ _ _ _ _ _ _ n
Theorem: SetTheory.PGame.quot_right_distrib_sub
File: Mathlib/SetTheory/Game/Basic.lean

Proof steps:
state_before: x y z : PGame
⊢ ⟦(y - z) * x⟧ = ⟦y * x⟧ - ⟦z * x⟧
state_after: x y z : PGame
⊢ ⟦(y + -z) * x⟧ = ⟦y * x⟧ + -⟦z * x⟧
tactic: change (⟦(y + -z) * x⟧ : Game) = ⟦y * x⟧ + -⟦z * x⟧
state_before: x y z : PGame
⊢ ⟦(y + -z) * x⟧ = ⟦y * x⟧ + -⟦z * x⟧
state_after: no goals
tactic: rw [quot_right_distrib, quot_neg_mul]
Theorem: Ordinal.principal_add_of_le_one
File: Mathlib/SetTheory/Ordinal/Principal.lean

Proof steps:
state_before: o : Ordinal.{u_1}
ho : o ≤ 1
⊢ Principal (fun x x_1 => x + x_1) o
state_after: case inl
ho : 0 ≤ 1
⊢ Principal (fun x x_1 => x + x_1) 0

case inr
ho : 1 ≤ 1
⊢ Principal (fun x x_1 => x + x_1) 1
tactic: rcases le_one_iff.1 ho with (rfl | rfl)
Theorem: toIcoMod_add_left'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoMod hp (p + a) b = p + toIcoMod hp a b
state_after: no goals
tactic: rw [add_comm, toIcoMod_add_right', add_comm]
Theorem: fderivWithin_mem_iff
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s✝ t✝ : Set E
L L₁ L₂ : Filter E
f : E → F
t : Set E
s : Set (E →L[𝕜] F)
x : E
⊢ fderivWithin 𝕜 f t x ∈ s ↔
    DifferentiableWithinAt 𝕜 f t x ∧ fderivWithin 𝕜 f t x ∈ s ∨ ¬DifferentiableWithinAt 𝕜 f t x ∧ 0 ∈ s
state_after: no goals
tactic: by_cases hx : DifferentiableWithinAt 𝕜 f t x <;>
    simp [fderivWithin_zero_of_not_differentiableWithinAt, *]
Theorem: CategoryTheory.ShortComplex.descOpcycles_comp
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{?u.210892, u_1} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
A : C
k : S.X₂ ⟶ A
hk : S.f ≫ k = 0
inst✝ : S.HasRightHomology
A' : C
α : A ⟶ A'
⊢ S.f ≫ k ≫ α = 0
state_after: no goals
tactic: rw [reassoc_of% hk, zero_comp]
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
A : C
k : S.X₂ ⟶ A
hk : S.f ≫ k = 0
inst✝ : S.HasRightHomology
A' : C
α : A ⟶ A'
⊢ S.descOpcycles k hk ≫ α = S.descOpcycles (k ≫ α) ⋯
state_after: no goals
tactic: simp only [← cancel_epi S.pOpcycles, p_descOpcycles_assoc, p_descOpcycles]
Theorem: AlgebraicGeometry.SheafedSpace.IsOpenImmersion.to_iso
File: Mathlib/Geometry/RingedSpace/OpenImmersion.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : SheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
h' : Epi f.base
⊢ IsIso f
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : SheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
h' : Epi f.base
this : IsIso (forgetToPresheafedSpace.map f)
⊢ IsIso f
tactic: haveI : IsIso (forgetToPresheafedSpace.map f) := PresheafedSpace.IsOpenImmersion.to_iso f
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : SheafedSpace C
f : X ⟶ Y
H : IsOpenImmersion f
h' : Epi f.base
this : IsIso (forgetToPresheafedSpace.map f)
⊢ IsIso f
state_after: no goals
tactic: apply isIso_of_reflects_iso _ (SheafedSpace.forgetToPresheafedSpace)
Theorem: FormalMultilinearSeries.order_eq_find
File: Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean

Proof steps:
state_before: 𝕜 : Type u
𝕜' : Type u'
E : Type v
F : Type w
G : Type x
inst✝¹¹ : Ring 𝕜
n : ℕ
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : Module 𝕜 E
inst✝⁸ : TopologicalSpace E
inst✝⁷ : TopologicalAddGroup E
inst✝⁶ : ContinuousConstSMul 𝕜 E
inst✝⁵ : AddCommGroup F
inst✝⁴ : Module 𝕜 F
inst✝³ : TopologicalSpace F
inst✝² : TopologicalAddGroup F
inst✝¹ : ContinuousConstSMul 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
inst✝ : DecidablePred fun n => p n ≠ 0
hp : ∃ n, p n ≠ 0
⊢ p.order = Nat.find hp
state_after: no goals
tactic: convert Nat.sInf_def hp
Theorem: Pell.xz_succ_succ
File: Mathlib/NumberTheory/PellMatiyasevic.lean

Proof steps:
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ xz a1 (n + 2) + xz a1 n = ↑(2 * a) * xz a1 (n + 1)
state_after: a : ℕ
a1 : 1 < a
n : ℕ
⊢ ↑(xn a1 (n + 2)) + ↑(xn a1 n) = ↑(2 * a) * ↑(xn a1 (n + 1))
tactic: delta xz
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ ↑(xn a1 (n + 2)) + ↑(xn a1 n) = ↑(2 * a) * ↑(xn a1 (n + 1))
state_after: no goals
tactic: rw [← Int.ofNat_add, ← Int.ofNat_mul, xn_succ_succ]
Theorem: Inducing.continuous_iff
File: Mathlib/Topology/Maps/Basic.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
hg : Inducing g
⊢ Continuous f ↔ Continuous (g ∘ f)
state_after: no goals
tactic: simp_rw [continuous_iff_continuousAt, hg.continuousAt_iff]
Theorem: CancelDenoms.div_subst
File: Mathlib/Tactic/CancelDenoms/Core.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Field α
n1 n2 k e1 e2 t1 : α
h1 : n1 * e1 = t1
h2 : n2 / e2 = 1
h3 : n1 * n2 = k
⊢ k * (e1 / e2) = t1
state_after: no goals
tactic: rw [← h3, mul_assoc, mul_div_left_comm, h2, ← mul_assoc, h1, mul_comm, one_mul]
Theorem: Matrix.one_mul
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : NonAssocSemiring α
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n α
⊢ 1 * M = M
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : NonAssocSemiring α
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n α
i✝ : m
j✝ : n
⊢ (1 * M) i✝ j✝ = M i✝ j✝
tactic: ext
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : NonAssocSemiring α
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n α
i✝ : m
j✝ : n
⊢ (1 * M) i✝ j✝ = M i✝ j✝
state_after: no goals
tactic: rw [← diagonal_one, diagonal_mul, one_mul]
Theorem: HurwitzZeta.cosZeta_zero
File: Mathlib/NumberTheory/LSeries/RiemannZeta.lean

Proof steps:
state_before: ⊢ cosZeta 0 = riemannZeta
state_after: no goals
tactic: simp_rw [cosZeta, riemannZeta, hurwitzZetaEven, if_true, completedHurwitzZetaEven_zero,
    completedCosZeta_zero]
Theorem: linearIndependent_fin_succ
File: Mathlib/LinearAlgebra/LinearIndependent.lean

Proof steps:
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v✝ : ι → V
s t : Set V
x y z : V
n : ℕ
v : Fin (n + 1) → V
⊢ LinearIndependent K v ↔ LinearIndependent K (Fin.tail v) ∧ v 0 ∉ span K (range (Fin.tail v))
state_after: no goals
tactic: rw [← linearIndependent_fin_cons, Fin.cons_self_tail]
Theorem: Int.ediv_of_neg_of_pos
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a✝ b✝ c d m✝ n✝ a b : ℤ
m n : ℕ
Ha : -[m+1] < 0
Hb : 0 < ↑n.succ
⊢ -[m+1].ediv ↑n.succ = -((- -[m+1] - 1) / ↑n.succ + 1)
state_after: a✝ b✝ c d m✝ n✝ a b : ℤ
m n : ℕ
Ha : -[m+1] < 0
Hb : 0 < ↑n.succ
⊢ -[m+1].ediv ↑n.succ = -((↑m + 1 - 1) / ↑n.succ + 1)
tactic: rw [show (- -[m+1] : ℤ) = (m + 1 : ℤ) by rfl]
state_before: a✝ b✝ c d m✝ n✝ a b : ℤ
m n : ℕ
Ha : -[m+1] < 0
Hb : 0 < ↑n.succ
⊢ -[m+1].ediv ↑n.succ = -((↑m + 1 - 1) / ↑n.succ + 1)
state_after: a✝ b✝ c d m✝ n✝ a b : ℤ
m n : ℕ
Ha : -[m+1] < 0
Hb : 0 < ↑n.succ
⊢ -[m+1].ediv ↑n.succ = -(↑m / ↑n.succ + 1)
tactic: rw [Int.add_sub_cancel]
state_before: a✝ b✝ c d m✝ n✝ a b : ℤ
m n : ℕ
Ha : -[m+1] < 0
Hb : 0 < ↑n.succ
⊢ -[m+1].ediv ↑n.succ = -(↑m / ↑n.succ + 1)
state_after: no goals
tactic: rfl
Theorem: BoxIntegral.HasIntegral.add
File: Mathlib/Analysis/BoxIntegral/Basic.lean

Proof steps:
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
h : HasIntegral I l f vol y
h' : HasIntegral I l g vol y'
⊢ HasIntegral I l (f + g) vol (y + y')
state_after: no goals
tactic: simpa only [HasIntegral, ← integralSum_add] using h.add h'
Theorem: Ideal.comap_radical
File: Mathlib/RingTheory/Ideal/Maps.lean

Proof steps:
state_before: R : Type u
S : Type v
F : Type u_1
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : FunLike F R S
rc : RingHomClass F R S
f : F
I J : Ideal R
K L : Ideal S
⊢ comap f K.radical = (comap f K).radical
state_after: case h
R : Type u
S : Type v
F : Type u_1
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : FunLike F R S
rc : RingHomClass F R S
f : F
I J : Ideal R
K L : Ideal S
x✝ : R
⊢ x✝ ∈ comap f K.radical ↔ x✝ ∈ (comap f K).radical
tactic: ext
state_before: case h
R : Type u
S : Type v
F : Type u_1
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : FunLike F R S
rc : RingHomClass F R S
f : F
I J : Ideal R
K L : Ideal S
x✝ : R
⊢ x✝ ∈ comap f K.radical ↔ x✝ ∈ (comap f K).radical
state_after: no goals
tactic: simp [radical]
Theorem: minpoly.prime
File: Mathlib/FieldTheory/Minpoly/Field.lean

Proof steps:
state_before: A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
⊢ Prime (minpoly A x)
state_after: A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
⊢ ∀ (a b : A[X]), minpoly A x ∣ a * b → minpoly A x ∣ a ∨ minpoly A x ∣ b
tactic: refine ⟨minpoly.ne_zero hx, not_isUnit A x, ?_⟩
state_before: A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
⊢ ∀ (a b : A[X]), minpoly A x ∣ a * b → minpoly A x ∣ a ∨ minpoly A x ∣ b
state_after: case intro
A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
p q d : A[X]
h : p * q = minpoly A x * d
⊢ minpoly A x ∣ p ∨ minpoly A x ∣ q
tactic: rintro p q ⟨d, h⟩
state_before: case intro
A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
p q d : A[X]
h : p * q = minpoly A x * d
⊢ minpoly A x ∣ p ∨ minpoly A x ∣ q
state_after: case intro
A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
p q d : A[X]
h : p * q = minpoly A x * d
this : (Polynomial.aeval x) (p * q) = 0
⊢ minpoly A x ∣ p ∨ minpoly A x ∣ q
tactic: have : Polynomial.aeval x (p * q) = 0 := by simp [h, aeval A x]
state_before: case intro
A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
p q d : A[X]
h : p * q = minpoly A x * d
this : (Polynomial.aeval x) (p * q) = 0
⊢ minpoly A x ∣ p ∨ minpoly A x ∣ q
state_after: case intro
A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
p q d : A[X]
h : p * q = minpoly A x * d
this : (Polynomial.aeval x) p = 0 ∨ (Polynomial.aeval x) q = 0
⊢ minpoly A x ∣ p ∨ minpoly A x ∣ q
tactic: replace : Polynomial.aeval x p = 0 ∨ Polynomial.aeval x q = 0 := by simpa
state_before: case intro
A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
p q d : A[X]
h : p * q = minpoly A x * d
this : (Polynomial.aeval x) p = 0 ∨ (Polynomial.aeval x) q = 0
⊢ minpoly A x ∣ p ∨ minpoly A x ∣ q
state_after: no goals
tactic: exact Or.imp (dvd A x) (dvd A x) this