1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Equiv.Perm.sameCycle_inv_apply_left
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rw [← sameCycle_apply_left, apply_inv_self]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
p : α → Prop
x y z : α
⊢ f.SameCycle (f⁻¹ x) y ↔ f.SameCycle x y
state_after: no goals
Theorem: FiberBundle.chartedSpace_chartAt_symm_fst
File: Mathlib/Geometry/Manifold/VectorBundle/Basic.lean

tactic: simp only [FiberBundle.chartedSpace_chartAt, mfld_simps] at hy ⊢
state_before: 𝕜 : Type u_1
B : Type u_2
B' : Type u_3
F : Type u_4
M : Type u_5
E : B → Type u_6
inst✝⁶ : TopologicalSpace F
inst✝⁵ : TopologicalSpace (TotalSpace F E)
inst✝⁴ : (x : B) → TopologicalSpace (E x)
HB : Type u_7
inst✝³ : TopologicalSpace HB
inst✝² : TopologicalSpace B
inst✝¹ : ChartedSpace HB B
inst✝ : FiberBundle F E
x : TotalSpace F E
y : ModelProd HB F
hy : y ∈ (chartAt (ModelProd HB F) x).target
⊢ (↑(chartAt (ModelProd HB F) x).symm y).proj = ↑(chartAt HB x.proj).symm y.1
state_after: 𝕜 : Type u_1
B : Type u_2
B' : Type u_3
F : Type u_4
M : Type u_5
E : B → Type u_6
inst✝⁶ : TopologicalSpace F
inst✝⁵ : TopologicalSpace (TotalSpace F E)
inst✝⁴ : (x : B) → TopologicalSpace (E x)
HB : Type u_7
inst✝³ : TopologicalSpace HB
inst✝² : TopologicalSpace B
inst✝¹ : ChartedSpace HB B
inst✝ : FiberBundle F E
x : TotalSpace F E
y : ModelProd HB F
hy :
  y ∈ (chartAt HB x.proj).target ×ˢ univ ∧
    ↑((chartAt HB x.proj).prod (PartialEquiv.refl F)).symm y ∈ (trivializationAt F E x.proj).target
⊢ (↑(trivializationAt F E x.proj).symm (↑((chartAt HB x.proj).prod (PartialHomeomorph.refl F)).symm y)).proj =
    ↑(chartAt HB x.proj).symm y.1

tactic: exact (trivializationAt F E x.proj).proj_symm_apply hy.2
state_before: 𝕜 : Type u_1
B : Type u_2
B' : Type u_3
F : Type u_4
M : Type u_5
E : B → Type u_6
inst✝⁶ : TopologicalSpace F
inst✝⁵ : TopologicalSpace (TotalSpace F E)
inst✝⁴ : (x : B) → TopologicalSpace (E x)
HB : Type u_7
inst✝³ : TopologicalSpace HB
inst✝² : TopologicalSpace B
inst✝¹ : ChartedSpace HB B
inst✝ : FiberBundle F E
x : TotalSpace F E
y : ModelProd HB F
hy :
  y ∈ (chartAt HB x.proj).target ×ˢ univ ∧
    ↑((chartAt HB x.proj).prod (PartialEquiv.refl F)).symm y ∈ (trivializationAt F E x.proj).target
⊢ (↑(trivializationAt F E x.proj).symm (↑((chartAt HB x.proj).prod (PartialHomeomorph.refl F)).symm y)).proj =
    ↑(chartAt HB x.proj).symm y.1
state_after: no goals
Theorem: CochainComplex.shiftFunctorAdd'_inv_app_f'
File: Mathlib/Algebra/Homology/HomotopyCategory/Shift.lean

tactic: dsimp
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
a b ab : ℤ
h : a + b = ab
n : ℤ
⊢ n + { as := b }.as + { as := a }.as = n + { as := ab }.as
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
a b ab : ℤ
h : a + b = ab
n : ℤ
⊢ n + b + a = n + ab

tactic: rw [← h, add_assoc, add_comm a]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
a b ab : ℤ
h : a + b = ab
n : ℤ
⊢ n + b + a = n + ab
state_after: no goals

tactic: subst h
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
a b ab : ℤ
h : a + b = ab
n : ℤ
⊢ ((CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) a b ab h).inv.app K).f n = (XIsoOfEq K ⋯).hom
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
a b n : ℤ
⊢ ((CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) a b (a + b) ⋯).inv.app K).f n = (XIsoOfEq K ⋯).hom

tactic: rw [shiftFunctorAdd'_eq_shiftFunctorAdd, shiftFunctorAdd_inv_app_f]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
K : CochainComplex C ℤ
a b n : ℤ
⊢ ((CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) a b (a + b) ⋯).inv.app K).f n = (XIsoOfEq K ⋯).hom
state_after: no goals
Theorem: CategoryTheory.PreGaloisCategory.autGaloisSystem_map_surjective
File: Mathlib/CategoryTheory/Galois/Prorepresentability.lean

tactic: intro (φ : Aut B.obj)
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
A B : PointedGaloisObject F
f : A ⟶ B
⊢ Function.Surjective ⇑((autGaloisSystem F).map f)
state_after: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
A B : PointedGaloisObject F
f : A ⟶ B
φ : Aut B.obj
⊢ ∃ a, ((autGaloisSystem F).map f) a = φ

tactic: obtain ⟨ψ, hψ⟩ := autMap_surjective_of_isGalois f.val φ
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
A B : PointedGaloisObject F
f : A ⟶ B
φ : Aut B.obj
⊢ ∃ a, ((autGaloisSystem F).map f) a = φ
state_after: case intro
C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
A B : PointedGaloisObject F
f : A ⟶ B
φ : Aut B.obj
ψ : Aut A.obj
hψ : autMap f.val ψ = φ
⊢ ∃ a, ((autGaloisSystem F).map f) a = φ

tactic: use ψ
state_before: case intro
C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
A B : PointedGaloisObject F
f : A ⟶ B
φ : Aut B.obj
ψ : Aut A.obj
hψ : autMap f.val ψ = φ
⊢ ∃ a, ((autGaloisSystem F).map f) a = φ
state_after: case h
C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
A B : PointedGaloisObject F
f : A ⟶ B
φ : Aut B.obj
ψ : Aut A.obj
hψ : autMap f.val ψ = φ
⊢ ((autGaloisSystem F).map f) ψ = φ

tactic: simp only [autGaloisSystem_map]
state_before: case h
C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
A B : PointedGaloisObject F
f : A ⟶ B
φ : Aut B.obj
ψ : Aut A.obj
hψ : autMap f.val ψ = φ
⊢ ((autGaloisSystem F).map f) ψ = φ
state_after: case h
C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
A B : PointedGaloisObject F
f : A ⟶ B
φ : Aut B.obj
ψ : Aut A.obj
hψ : autMap f.val ψ = φ
⊢ (autMapHom f.val) ψ = φ

tactic: exact hψ
state_before: case h
C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
A B : PointedGaloisObject F
f : A ⟶ B
φ : Aut B.obj
ψ : Aut A.obj
hψ : autMap f.val ψ = φ
⊢ (autMapHom f.val) ψ = φ
state_after: no goals
Theorem: Order.pred_eq_pred_iff
File: Mathlib/Order/SuccPred/Basic.lean

tactic: simp_rw [eq_iff_le_not_lt, pred_le_pred_iff, pred_lt_pred_iff]
state_before: α : Type u_1
β : Type u_2
inst✝² : PartialOrder α
inst✝¹ : PredOrder α
a b : α
inst✝ : NoMinOrder α
⊢ pred a = pred b ↔ a = b
state_after: no goals
Theorem: AlgebraicGeometry.IsSeparated.isSeparated_eq_diagonal_isClosedImmersion
File: Mathlib/AlgebraicGeometry/Morphisms/Separated.lean

tactic: ext
state_before: X Y : Scheme
f : X ⟶ Y
⊢ @IsSeparated = MorphismProperty.diagonal @IsClosedImmersion
state_after: case h.h.h.a
X Y : Scheme
f : X ⟶ Y
x✝² x✝¹ : Scheme
x✝ : x✝² ⟶ x✝¹
⊢ IsSeparated x✝ ↔ MorphismProperty.diagonal (@IsClosedImmersion) x✝

tactic: exact isSeparated_iff _
state_before: case h.h.h.a
X Y : Scheme
f : X ⟶ Y
x✝² x✝¹ : Scheme
x✝ : x✝² ⟶ x✝¹
⊢ IsSeparated x✝ ↔ MorphismProperty.diagonal (@IsClosedImmersion) x✝
state_after: no goals
Theorem: DualNumber.exp_smul_eps
File: Mathlib/Analysis/NormedSpace/DualNumber.lean

tactic: rw [eps, ← inr_smul, exp_inr]
state_before: 𝕜 : Type u_1
R : Type u_2
inst✝⁷ : Field 𝕜
inst✝⁶ : CharZero 𝕜
inst✝⁵ : CommRing R
inst✝⁴ : Algebra 𝕜 R
inst✝³ : UniformSpace R
inst✝² : TopologicalRing R
inst✝¹ : CompleteSpace R
inst✝ : T2Space R
r : R
⊢ exp 𝕜 (r • ε) = 1 + r • ε
state_after: no goals
Theorem: MeasureTheory.Measure.Regular.map
File: Mathlib/MeasureTheory/Measure/Regular.lean

tactic: haveI := OuterRegular.map f μ
state_before: α : Type u_1
β : Type u_2
inst✝⁶ : MeasurableSpace α
inst✝⁵ : TopologicalSpace α
μ : Measure α
inst✝⁴ : BorelSpace α
inst✝³ : MeasurableSpace β
inst✝² : TopologicalSpace β
inst✝¹ : BorelSpace β
inst✝ : μ.Regular
f : α ≃ₜ β
⊢ (map (⇑f) μ).Regular
state_after: α : Type u_1
β : Type u_2
inst✝⁶ : MeasurableSpace α
inst✝⁵ : TopologicalSpace α
μ : Measure α
inst✝⁴ : BorelSpace α
inst✝³ : MeasurableSpace β
inst✝² : TopologicalSpace β
inst✝¹ : BorelSpace β
inst✝ : μ.Regular
f : α ≃ₜ β
this : (map (⇑f) μ).OuterRegular
⊢ (map (⇑f) μ).Regular

tactic: haveI := IsFiniteMeasureOnCompacts.map μ f
state_before: α : Type u_1
β : Type u_2
inst✝⁶ : MeasurableSpace α
inst✝⁵ : TopologicalSpace α
μ : Measure α
inst✝⁴ : BorelSpace α
inst✝³ : MeasurableSpace β
inst✝² : TopologicalSpace β
inst✝¹ : BorelSpace β
inst✝ : μ.Regular
f : α ≃ₜ β
this : (map (⇑f) μ).OuterRegular
⊢ (map (⇑f) μ).Regular
state_after: α : Type u_1
β : Type u_2
inst✝⁶ : MeasurableSpace α
inst✝⁵ : TopologicalSpace α
μ : Measure α
inst✝⁴ : BorelSpace α
inst✝³ : MeasurableSpace β
inst✝² : TopologicalSpace β
inst✝¹ : BorelSpace β
inst✝ : μ.Regular
f : α ≃ₜ β
this✝ : (map (⇑f) μ).OuterRegular
this : IsFiniteMeasureOnCompacts (map (⇑f) μ)
⊢ (map (⇑f) μ).Regular

tactic: exact
  ⟨Regular.innerRegular.map' f.toMeasurableEquiv
      (fun U hU => hU.preimage f.continuous)
      (fun K hK => hK.image f.continuous)⟩
state_before: α : Type u_1
β : Type u_2
inst✝⁶ : MeasurableSpace α
inst✝⁵ : TopologicalSpace α
μ : Measure α
inst✝⁴ : BorelSpace α
inst✝³ : MeasurableSpace β
inst✝² : TopologicalSpace β
inst✝¹ : BorelSpace β
inst✝ : μ.Regular
f : α ≃ₜ β
this✝ : (map (⇑f) μ).OuterRegular
this : IsFiniteMeasureOnCompacts (map (⇑f) μ)
⊢ (map (⇑f) μ).Regular
state_after: no goals
Theorem: Set.Sized.upShadow
File: Mathlib/Combinatorics/SetFamily/Shadow.lean

tactic: intro A h
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
h𝒜 : Set.Sized r ↑𝒜
⊢ Set.Sized (r + 1) ↑(∂⁺ 𝒜)
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
h𝒜 : Set.Sized r ↑𝒜
A : Finset α
h : A ∈ ↑(∂⁺ 𝒜)
⊢ A.card = r + 1

tactic: obtain ⟨A, hA, i, hi, rfl⟩ := mem_upShadow_iff.1 h
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
h𝒜 : Set.Sized r ↑𝒜
A : Finset α
h : A ∈ ↑(∂⁺ 𝒜)
⊢ A.card = r + 1
state_after: case intro.intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
h𝒜 : Set.Sized r ↑𝒜
A : Finset α
hA : A ∈ 𝒜
i : α
hi : i ∉ A
h : insert i A ∈ ↑(∂⁺ 𝒜)
⊢ (insert i A).card = r + 1

tactic: rw [card_insert_of_not_mem hi, h𝒜 hA]
state_before: case intro.intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
h𝒜 : Set.Sized r ↑𝒜
A : Finset α
hA : A ∈ 𝒜
i : α
hi : i ∉ A
h : insert i A ∈ ↑(∂⁺ 𝒜)
⊢ (insert i A).card = r + 1
state_after: no goals
Theorem: FractionalIdeal.mul_right_mono
File: Mathlib/RingTheory/FractionalIdeal/Basic.lean

tactic: intro J J' h
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : FractionalIdeal S P
⊢ Monotone fun J => J * I
state_after: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I J J' : FractionalIdeal S P
h : J ≤ J'
⊢ (fun J => J * I) J ≤ (fun J => J * I) J'

tactic: simp only [mul_def]
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I J J' : FractionalIdeal S P
h : J ≤ J'
⊢ (fun J => J * I) J ≤ (fun J => J * I) J'
state_after: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I J J' : FractionalIdeal S P
h : J ≤ J'
⊢ ⟨↑J * ↑I, ⋯⟩ ≤ ⟨↑J' * ↑I, ⋯⟩

tactic: exact mul_le.mpr fun x hx y hy => mul_mem_mul (h hx) hy
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I J J' : FractionalIdeal S P
h : J ≤ J'
⊢ ⟨↑J * ↑I, ⋯⟩ ≤ ⟨↑J' * ↑I, ⋯⟩
state_after: no goals
Theorem: Polynomial.natSepDegree_pow
File: Mathlib/FieldTheory/SeparableDegree.lean

tactic: simp only [natSepDegree_eq_of_isAlgClosed (AlgebraicClosure F), aroots_pow]
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
f : F[X]
n : ℕ
⊢ (f ^ n).natSepDegree = if n = 0 then 0 else f.natSepDegree
state_after: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
f : F[X]
n : ℕ
⊢ (n • f.aroots (AlgebraicClosure F)).toFinset.card = if n = 0 then 0 else (f.aroots (AlgebraicClosure F)).toFinset.card

tactic: by_cases h : n = 0
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
f : F[X]
n : ℕ
⊢ (n • f.aroots (AlgebraicClosure F)).toFinset.card = if n = 0 then 0 else (f.aroots (AlgebraicClosure F)).toFinset.card
state_after: case pos
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
f : F[X]
n : ℕ
h : n = 0
⊢ (n • f.aroots (AlgebraicClosure F)).toFinset.card = if n = 0 then 0 else (f.aroots (AlgebraicClosure F)).toFinset.card

case neg
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
f : F[X]
n : ℕ
h : ¬n = 0
⊢ (n • f.aroots (AlgebraicClosure F)).toFinset.card = if n = 0 then 0 else (f.aroots (AlgebraicClosure F)).toFinset.card

tactic: simp only [h, Multiset.toFinset_nsmul _ n h, ite_false]
state_before: case neg
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
f : F[X]
n : ℕ
h : ¬n = 0
⊢ (n • f.aroots (AlgebraicClosure F)).toFinset.card = if n = 0 then 0 else (f.aroots (AlgebraicClosure F)).toFinset.card
state_after: no goals

tactic: simp only [h, zero_smul, Multiset.toFinset_zero, Finset.card_empty, ite_true]
state_before: case pos
F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
f : F[X]
n : ℕ
h : n = 0
⊢ (n • f.aroots (AlgebraicClosure F)).toFinset.card = if n = 0 then 0 else (f.aroots (AlgebraicClosure F)).toFinset.card
state_after: no goals
Theorem: add_sq'
File: Mathlib/Algebra/Ring/Defs.lean

tactic: rw [add_sq, add_assoc, add_comm _ (b ^ 2), add_assoc]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : CommSemiring α
a✝ b✝ c a b : α
⊢ (a + b) ^ 2 = a ^ 2 + b ^ 2 + 2 * a * b
state_after: no goals
Theorem: Ordnode.any_iff_exists
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rintro ⟨⟩
state_before: α : Type u_1
P : α → Prop
⊢ Any P nil → ∃ x, Emem x nil ∧ P x
state_after: no goals

tactic: rintro ⟨_, ⟨⟩, _⟩
state_before: α : Type u_1
P : α → Prop
⊢ (∃ x, Emem x nil ∧ P x) → Any P nil
state_after: no goals

tactic: simp only [Emem]
state_before: α : Type u_1
P : α → Prop
size✝ : ℕ
l : Ordnode α
x : α
r : Ordnode α
⊢ Any P (node size✝ l x r) ↔ ∃ x_1, Emem x_1 (node size✝ l x r) ∧ P x_1
state_after: α : Type u_1
P : α → Prop
size✝ : ℕ
l : Ordnode α
x : α
r : Ordnode α
⊢ Any P (node size✝ l x r) ↔ ∃ x_1, Any (Eq x_1) (node size✝ l x r) ∧ P x_1

tactic: simp [Any, any_iff_exists, or_and_right, exists_or]
state_before: α : Type u_1
P : α → Prop
size✝ : ℕ
l : Ordnode α
x : α
r : Ordnode α
⊢ Any P (node size✝ l x r) ↔ ∃ x_1, Any (Eq x_1) (node size✝ l x r) ∧ P x_1
state_after: no goals
Theorem: CauSeq.mul_equiv_zero'
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

tactic: simpa
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
g f : CauSeq β abv
hf : f ≈ 0
this : (f - 0).LimZero
⊢ f.LimZero
state_after: no goals

tactic: simpa
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
g f : CauSeq β abv
hf : f ≈ 0
this✝ : (f - 0).LimZero
this : (f * g).LimZero
⊢ (f * g - 0).LimZero
state_after: no goals
Theorem: Fintype.prod_lt_one_iff_of_le_one
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

tactic: obtain rfl | hf := hf.eq_or_lt <;> simp [*, prod_lt_one]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : Fintype ι
inst✝ : OrderedCancelCommMonoid M
f : ι → M
hf : f ≤ 1
⊢ ∏ i : ι, f i < 1 ↔ f < 1
state_after: no goals
Theorem: hasSum_mul_left_iff
File: Mathlib/Topology/Algebra/InfiniteSum/Ring.lean

tactic: simpa only [inv_mul_cancel_left₀ h] using H.mul_left a₂⁻¹
state_before: ι : Type u_1
κ : Type u_2
R : Type u_3
α : Type u_4
inst✝² : DivisionSemiring α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSemiring α
f g : ι → α
a a₁ a₂ : α
h : a₂ ≠ 0
H : HasSum (fun i => a₂ * f i) (a₂ * a₁)
⊢ HasSum f a₁
state_after: no goals
Theorem: round_intCast
File: Mathlib/Algebra/Order/Floor.lean

tactic: simp [round]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
n : ℤ
⊢ round ↑n = n
state_after: no goals
Theorem: List.headI_add_tail_sum
File: Mathlib/Algebra/BigOperators/Group/List.lean

tactic: cases L <;> simp
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
L : List ℕ
⊢ L.headI + L.tail.sum = L.sum
state_after: no goals
Theorem: infClosed_singleton
File: Mathlib/Order/SupClosed.lean

tactic: simp [InfClosed]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf β
ι : Sort u_4
S : Set (Set α)
f : ι → Set α
s t : Set α
a : α
⊢ InfClosed {a}
state_after: no goals
Theorem: Multiset.toFinset_add
File: Mathlib/Data/Finset/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t✝ s t : Multiset α
⊢ ∀ (a : α), a ∈ (s + t).toFinset ↔ a ∈ s.toFinset ∪ t.toFinset
state_after: no goals
Theorem: CategoryTheory.Limits.zeroProdIso_inv_snd
File: Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean

tactic: dsimp [zeroProdIso, binaryFanZeroLeft]
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ (zeroProdIso X).inv ≫ prod.snd = 𝟙 X
state_after: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ (limit.isoLimitCone { cone := BinaryFan.mk 0 (𝟙 X), isLimit := binaryFanZeroLeftIsLimit X }).inv ≫ prod.snd = 𝟙 X

tactic: simp
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ (limit.isoLimitCone { cone := BinaryFan.mk 0 (𝟙 X), isLimit := binaryFanZeroLeftIsLimit X }).inv ≫ prod.snd = 𝟙 X
state_after: no goals
Theorem: Nat.factorizationLCMLeft_mul_factorizationLCMRight
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: rw [← factorization_prod_pow_eq_self (lcm_ne_zero ha hb), factorizationLCMLeft,
  factorizationLCMRight, ← prod_mul]
state_before: a b m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ a.factorizationLCMLeft b * a.factorizationLCMRight b = a.lcm b
state_after: a b m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ ((a.lcm b).factorization.prod fun a_1 b_1 =>
      (if b.factorization a_1 ≤ a.factorization a_1 then a_1 ^ b_1 else 1) *
        if b.factorization a_1 ≤ a.factorization a_1 then 1 else a_1 ^ b_1) =
    (a.lcm b).factorization.prod fun x x_1 => x ^ x_1

tactic: congr
state_before: a b m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ ((a.lcm b).factorization.prod fun a_1 b_1 =>
      (if b.factorization a_1 ≤ a.factorization a_1 then a_1 ^ b_1 else 1) *
        if b.factorization a_1 ≤ a.factorization a_1 then 1 else a_1 ^ b_1) =
    (a.lcm b).factorization.prod fun x x_1 => x ^ x_1
state_after: case e_g
a b m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ (fun a_1 b_1 =>
      (if b.factorization a_1 ≤ a.factorization a_1 then a_1 ^ b_1 else 1) *
        if b.factorization a_1 ≤ a.factorization a_1 then 1 else a_1 ^ b_1) =
    fun x x_1 => x ^ x_1

tactic: ext p n
state_before: case e_g
a b m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ (fun a_1 b_1 =>
      (if b.factorization a_1 ≤ a.factorization a_1 then a_1 ^ b_1 else 1) *
        if b.factorization a_1 ≤ a.factorization a_1 then 1 else a_1 ^ b_1) =
    fun x x_1 => x ^ x_1
state_after: case e_g.h.h
a b m n✝ p✝ : ℕ
ha : a ≠ 0
hb : b ≠ 0
p n : ℕ
⊢ ((if b.factorization p ≤ a.factorization p then p ^ n else 1) *
      if b.factorization p ≤ a.factorization p then 1 else p ^ n) =
    p ^ n

tactic: split_ifs <;> simp
state_before: case e_g.h.h
a b m n✝ p✝ : ℕ
ha : a ≠ 0
hb : b ≠ 0
p n : ℕ
⊢ ((if b.factorization p ≤ a.factorization p then p ^ n else 1) *
      if b.factorization p ≤ a.factorization p then 1 else p ^ n) =
    p ^ n
state_after: no goals
Theorem: norm_fderiv_iteratedFDeriv
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

tactic: rw [iteratedFDeriv_succ_eq_comp_left, comp_apply, LinearIsometryEquiv.norm_map]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
⊢ ‖fderiv 𝕜 (iteratedFDeriv 𝕜 n f) x‖ = ‖iteratedFDeriv 𝕜 (n + 1) f x‖
state_after: no goals
Theorem: Submodule.prodEquivOfIsCompl_symm_apply_right
File: Mathlib/LinearAlgebra/Projection.lean

tactic: simp
state_before: R : Type u_1
inst✝⁹ : Ring R
E : Type u_2
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type u_3
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type u_4
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type u_5
inst✝² : Semiring S
M : Type u_6
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
h : IsCompl p q
x : ↥q
⊢ ↑x = (p.prodEquivOfIsCompl q h) (0, x)
state_after: no goals
Theorem: Function.Antiperiodic.const_inv_smul₀
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [inv_inv] using h.const_smul₀ (inv_ne_zero ha)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝³ : AddCommMonoid α
inst✝² : Neg β
inst✝¹ : DivisionSemiring γ
inst✝ : Module γ α
h : Antiperiodic f c
a : γ
ha : a ≠ 0
⊢ Antiperiodic (fun x => f (a⁻¹ • x)) (a • c)
state_after: no goals