1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.Limits.factorThruKernelSubobject_comp_kernelSubobjectIso
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp
state_before: C : Type u
inst✝² : Category.{v, u} C
X Y Z : C
inst✝¹ : HasZeroMorphisms C
f : X ⟶ Y
inst✝ : HasKernel f
W : C
h : W ⟶ X
w : h ≫ f = 0
⊢ (factorThruKernelSubobject f h w ≫ (kernelSubobjectIso f).hom) ≫ kernel.ι f = kernel.lift f h w ≫ kernel.ι f
state_after: no goals
Theorem: goldConj_mul_gold
File: Mathlib/Data/Real/GoldenRatio.lean

tactic: rw [mul_comm]
state_before: ⊢ ψ * φ = -1
state_after: ⊢ φ * ψ = -1

tactic: exact gold_mul_goldConj
state_before: ⊢ φ * ψ = -1
state_after: no goals
Theorem: Bifunctor.snd_fst
File: Mathlib/Control/Bifunctor.lean

tactic: simp [snd, bimap_bimap]
state_before: F : Type u₀ → Type u₁ → Type u₂
inst✝¹ : Bifunctor F
inst✝ : LawfulBifunctor F
α₀ α₁ : Type u₀
β₀ β₁ : Type u₁
f : α₀ → α₁
f' : β₀ → β₁
x : F α₀ β₀
⊢ snd f' (fst f x) = bimap f f' x
state_after: no goals
Theorem: contDiff_iff_continuous_differentiable
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

tactic: simp [contDiffOn_univ.symm, continuous_iff_continuousOn_univ, differentiableOn_univ.symm,
  iteratedFDerivWithin_univ, contDiffOn_iff_continuousOn_differentiableOn uniqueDiffOn_univ]
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
⊢ ContDiff 𝕜 n f ↔
    (∀ (m : ℕ), ↑m ≤ n → Continuous fun x => iteratedFDeriv 𝕜 m f x) ∧
      ∀ (m : ℕ), ↑m < n → Differentiable 𝕜 fun x => iteratedFDeriv 𝕜 m f x
state_after: no goals
Theorem: MeasureTheory.JordanDecomposition.toSignedMeasure_zero
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

tactic: ext1 i hi
state_before: α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
j : JordanDecomposition α
⊢ toSignedMeasure 0 = 0
state_after: case h
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
j : JordanDecomposition α
i : Set α
hi : MeasurableSet i
⊢ ↑(toSignedMeasure 0) i = ↑0 i

tactic: rw [toSignedMeasure, toSignedMeasure_sub_apply hi, zero_posPart, zero_negPart, sub_self,
  VectorMeasure.coe_zero, Pi.zero_apply]
state_before: case h
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
j : JordanDecomposition α
i : Set α
hi : MeasurableSet i
⊢ ↑(toSignedMeasure 0) i = ↑0 i
state_after: no goals
Theorem: CategoryTheory.ShortComplex.opcyclesMap'_g'
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

tactic: simp only [← cancel_epi h₁.p, assoc, φ.comm₂₃, p_opcyclesMap'_assoc,
  RightHomologyData.p_g'_assoc, RightHomologyData.p_g']
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.RightHomologyData
h₂ : S₂.RightHomologyData
⊢ opcyclesMap' φ h₁ h₂ ≫ h₂.g' = h₁.g' ≫ φ.τ₃
state_after: no goals
Theorem: Finset.forall_mem_insert
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_insert, or_imp, forall_and, forall_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
a : α
s : Finset α
p : α → Prop
⊢ (∀ x ∈ insert a s, p x) ↔ p a ∧ ∀ x ∈ s, p x
state_after: no goals
Theorem: WithTop.add_left_cancel_iff
File: Mathlib/Algebra/Order/Monoid/WithTop.lean

tactic: lift a to α using ha
state_before: α : Type u
β : Type v
inst✝¹ : Add α
a b c d : WithTop α
x y : α
inst✝ : IsLeftCancelAdd α
ha : a ≠ ⊤
⊢ a + b = a + c ↔ b = c
state_after: case intro
α : Type u
β : Type v
inst✝¹ : Add α
b c d : WithTop α
x y : α
inst✝ : IsLeftCancelAdd α
a : α
⊢ ↑a + b = ↑a + c ↔ b = c

tactic: obtain rfl | hb := eq_or_ne b ⊤
state_before: case intro
α : Type u
β : Type v
inst✝¹ : Add α
b c d : WithTop α
x y : α
inst✝ : IsLeftCancelAdd α
a : α
⊢ ↑a + b = ↑a + c ↔ b = c
state_after: case intro.inl
α : Type u
β : Type v
inst✝¹ : Add α
c d : WithTop α
x y : α
inst✝ : IsLeftCancelAdd α
a : α
⊢ ↑a + ⊤ = ↑a + c ↔ ⊤ = c

case intro.inr
α : Type u
β : Type v
inst✝¹ : Add α
b c d : WithTop α
x y : α
inst✝ : IsLeftCancelAdd α
a : α
hb : b ≠ ⊤
⊢ ↑a + b = ↑a + c ↔ b = c

tactic: lift b to α using hb
state_before: case intro.inr
α : Type u
β : Type v
inst✝¹ : Add α
b c d : WithTop α
x y : α
inst✝ : IsLeftCancelAdd α
a : α
hb : b ≠ ⊤
⊢ ↑a + b = ↑a + c ↔ b = c
state_after: case intro.inr.intro
α : Type u
β : Type v
inst✝¹ : Add α
c d : WithTop α
x y : α
inst✝ : IsLeftCancelAdd α
a b : α
⊢ ↑a + ↑b = ↑a + c ↔ ↑b = c

tactic: simp_rw [← WithTop.coe_add, eq_comm, WithTop.add_eq_coe, eq_comm, coe_eq_coe,
  exists_and_left, exists_eq_left', add_right_inj, exists_eq_right']
state_before: case intro.inr.intro
α : Type u
β : Type v
inst✝¹ : Add α
c d : WithTop α
x y : α
inst✝ : IsLeftCancelAdd α
a b : α
⊢ ↑a + ↑b = ↑a + c ↔ ↑b = c
state_after: no goals

tactic: rw [add_top, eq_comm, WithTop.coe_add_eq_top_iff, eq_comm]
state_before: case intro.inl
α : Type u
β : Type v
inst✝¹ : Add α
c d : WithTop α
x y : α
inst✝ : IsLeftCancelAdd α
a : α
⊢ ↑a + ⊤ = ↑a + c ↔ ⊤ = c
state_after: no goals
Theorem: SimpleGraph.Subgraph.verts_spanningCoe_injective
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: intro G₁ G₂ h
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
⊢ Function.Injective fun G' => (G'.verts, G'.spanningCoe)
state_after: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁✝ G₂✝ : G.Subgraph
a b : V
G₁ G₂ : G.Subgraph
h : (fun G' => (G'.verts, G'.spanningCoe)) G₁ = (fun G' => (G'.verts, G'.spanningCoe)) G₂
⊢ G₁ = G₂

tactic: rw [Prod.ext_iff] at h
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁✝ G₂✝ : G.Subgraph
a b : V
G₁ G₂ : G.Subgraph
h : (fun G' => (G'.verts, G'.spanningCoe)) G₁ = (fun G' => (G'.verts, G'.spanningCoe)) G₂
⊢ G₁ = G₂
state_after: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁✝ G₂✝ : G.Subgraph
a b : V
G₁ G₂ : G.Subgraph
h :
  ((fun G' => (G'.verts, G'.spanningCoe)) G₁).1 = ((fun G' => (G'.verts, G'.spanningCoe)) G₂).1 ∧
    ((fun G' => (G'.verts, G'.spanningCoe)) G₁).2 = ((fun G' => (G'.verts, G'.spanningCoe)) G₂).2
⊢ G₁ = G₂

tactic: exact Subgraph.ext _ _ h.1 (spanningCoe_inj.1 h.2)
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁✝ G₂✝ : G.Subgraph
a b : V
G₁ G₂ : G.Subgraph
h :
  ((fun G' => (G'.verts, G'.spanningCoe)) G₁).1 = ((fun G' => (G'.verts, G'.spanningCoe)) G₂).1 ∧
    ((fun G' => (G'.verts, G'.spanningCoe)) G₁).2 = ((fun G' => (G'.verts, G'.spanningCoe)) G₂).2
⊢ G₁ = G₂
state_after: no goals
Theorem: Ordinal.le_add_right
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: simpa only [add_zero] using add_le_add_left (Ordinal.zero_le b) a
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal.{u_3}
⊢ a ≤ a + b
state_after: no goals
Theorem: inv_mul_le_iff_le_mul'
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [inv_mul_le_iff_le_mul, mul_comm]
state_before: α : Type u
inst✝² : CommGroup α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ c⁻¹ * a ≤ b ↔ a ≤ b * c
state_after: no goals
Theorem: zero_pow
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: rw [pow_succ, mul_zero]
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MonoidWithZero M₀
a : M₀
m n✝ n : ℕ
x✝ : n + 1 ≠ 0
⊢ 0 ^ (n + 1) = 0
state_after: no goals
Theorem: MeasureTheory.OuterMeasure.isometryEquiv_map_mkMetric
File: Mathlib/MeasureTheory/Measure/Hausdorff.lean

tactic: rw [← isometryEquiv_comap_mkMetric _ f, map_comap_of_surjective f.surjective]
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
m : ℝ≥0∞ → ℝ≥0∞
f : X ≃ᵢ Y
⊢ (map ⇑f) (mkMetric m) = mkMetric m
state_after: no goals
Theorem: sign_neg
File: Mathlib/Data/Sign.lean

tactic: rwa [sign_apply, if_neg <| asymm ha, if_pos]
state_before: α : Type u_1
inst✝² : Zero α
inst✝¹ : Preorder α
inst✝ : DecidableRel fun x x_1 => x < x_1
a : α
ha : a < 0
⊢ sign a = -1
state_after: no goals
Theorem: Matrix.updateColumn_transpose
File: Mathlib/Data/Matrix/RowCol.lean

tactic: ext
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝ : DecidableEq m
⊢ Mᵀ.updateColumn i b = (M.updateRow i b)ᵀ
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝ : DecidableEq m
i✝ : n
j✝ : m
⊢ Mᵀ.updateColumn i b i✝ j✝ = (M.updateRow i b)ᵀ i✝ j✝

tactic: rw [transpose_apply, updateRow_apply, updateColumn_apply]
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝ : DecidableEq m
i✝ : n
j✝ : m
⊢ Mᵀ.updateColumn i b i✝ j✝ = (M.updateRow i b)ᵀ i✝ j✝
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝ : DecidableEq m
i✝ : n
j✝ : m
⊢ (if j✝ = i then b i✝ else Mᵀ i✝ j✝) = if j✝ = i then b i✝ else M j✝ i✝

tactic: rfl
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i : m
j : n
b : n → α
c : m → α
inst✝ : DecidableEq m
i✝ : n
j✝ : m
⊢ (if j✝ = i then b i✝ else Mᵀ i✝ j✝) = if j✝ = i then b i✝ else M j✝ i✝
state_after: no goals
Theorem: CategoryTheory.Bifunctor.diagonal'
File: Mathlib/CategoryTheory/Products/Bifunctor.lean

tactic: rw [← Functor.map_comp, prod_comp, Category.id_comp, Category.comp_id]
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Category.{v₂, u₂} D
inst✝ : Category.{v₃, u₃} E
F : C × D ⥤ E
X X' : C
f : X ⟶ X'
Y Y' : D
g : Y ⟶ Y'
⊢ F.map (f, 𝟙 Y) ≫ F.map (𝟙 X', g) = F.map (f, g)
state_after: no goals
Theorem: Polynomial.comp_one
File: Mathlib/Algebra/Polynomial/Eval.lean

tactic: rw [← C_1, comp_C]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ p.comp 1 = C (eval 1 p)
state_after: no goals
Theorem: Equiv.exists_congr_right
File: Mathlib/Logic/Equiv/Defs.lean

tactic: simpa using h
state_before: α : Sort u
β : Sort v
γ : Sort w
p : α → Prop
q : β → Prop
e : α ≃ β
x✝ : ∃ b, q b
a : β
h : q a
⊢ q (e (e.symm a))
state_after: no goals
Theorem: Function.Commute.iterate_eq_of_map_eq
File: Mathlib/Logic/Function/Iterate.lean

tactic: simp only [iterate_succ_apply, hx, (h.iterate_left n).eq, ihn, ((refl g).iterate_right n).eq]
state_before: α : Type u
β : Type v
f g : α → α
h : Commute f g
n✝ : ℕ
x : α
hx : f x = g x
n : ℕ
ihn : f^[n] x = g^[n] x
⊢ f^[n.succ] x = g^[n.succ] x
state_after: no goals
Theorem: Submodule.restrictScalars_eq_top_iff
File: Mathlib/Algebra/Module/Submodule/RestrictScalars.lean

tactic: simp [SetLike.ext_iff]
state_before: S : Type u_1
R : Type u_2
M : Type u_3
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Semiring S
inst✝³ : Module S M
inst✝² : Module R M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p : Submodule R M
⊢ restrictScalars S p = ⊤ ↔ p = ⊤
state_after: no goals
Theorem: MeasureTheory.hasFiniteIntegral_iff_edist
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp only [hasFiniteIntegral_iff_norm, edist_dist, dist_zero_right]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
⊢ HasFiniteIntegral f μ ↔ ∫⁻ (a : α), edist (f a) 0 ∂μ < ⊤
state_after: no goals
Theorem: TensorProduct.directSum_symm_lof_tmul
File: Mathlib/LinearAlgebra/DirectSum/TensorProduct.lean

tactic: rw [LinearEquiv.symm_apply_eq, directSum_lof_tmul_lof]
state_before: R : Type u
inst✝¹⁴ : CommSemiring R
S : Type u_1
inst✝¹³ : Semiring S
inst✝¹² : Algebra R S
ι₁ : Type v₁
ι₂ : Type v₂
inst✝¹¹ : DecidableEq ι₁
inst✝¹⁰ : DecidableEq ι₂
M₁ : ι₁ → Type w₁
M₁' : Type w₁'
M₂ : ι₂ → Type w₂
M₂' : Type w₂'
inst✝⁹ : (i₁ : ι₁) → AddCommMonoid (M₁ i₁)
inst✝⁸ : AddCommMonoid M₁'
inst✝⁷ : (i₂ : ι₂) → AddCommMonoid (M₂ i₂)
inst✝⁶ : AddCommMonoid M₂'
inst✝⁵ : (i₁ : ι₁) → Module R (M₁ i₁)
inst✝⁴ : Module R M₁'
inst✝³ : (i₂ : ι₂) → Module R (M₂ i₂)
inst✝² : Module R M₂'
inst✝¹ : (i₁ : ι₁) → Module S (M₁ i₁)
inst✝ : ∀ (i₁ : ι₁), IsScalarTower R S (M₁ i₁)
i₁ : ι₁
m₁ : M₁ i₁
i₂ : ι₂
m₂ : M₂ i₂
⊢ (TensorProduct.directSum R S M₁ M₂).symm ((lof S (ι₁ × ι₂) (fun i => M₁ i.1 ⊗[R] M₂ i.2) (i₁, i₂)) (m₁ ⊗ₜ[R] m₂)) =
    (lof S ι₁ M₁ i₁) m₁ ⊗ₜ[R] (lof R ι₂ M₂ i₂) m₂
state_after: no goals
Theorem: Option.map₂_comm
File: Mathlib/Data/Option/NAry.lean

tactic: cases a <;> cases b <;> simp [h_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f : α → β → γ
a : Option α
b : Option β
c : Option γ
α' : Type u_5
β' : Type u_6
δ' : Type u_7
ε : Type u_8
ε' : Type u_9
g : β → α → γ
h_comm : ∀ (a : α) (b : β), f a b = g b a
⊢ map₂ f a b = map₂ g b a
state_after: no goals
Theorem: separableClosure.map_eq_of_algEquiv
File: Mathlib/FieldTheory/SeparableClosure.lean

tactic: simp
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
i : E ≃ₐ[F] K
x : K
h : x ∈ separableClosure F K
⊢ ↑↑i (↑i.symm x) = x
state_after: no goals
Theorem: summable_of_ratio_test_tendsto_lt_one
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: rcases exists_between hl₁ with ⟨r, hr₀, hr₁⟩
state_before: α✝ : Type u_1
β : Type u_2
ι : Type u_3
α : Type u_4
inst✝¹ : NormedAddCommGroup α
inst✝ : CompleteSpace α
f : ℕ → α
l : ℝ
hl₁ : l < 1
hf : ∀ᶠ (n : ℕ) in atTop, f n ≠ 0
h : Tendsto (fun n => ‖f (n + 1)‖ / ‖f n‖) atTop (𝓝 l)
⊢ Summable f
state_after: case intro.intro
α✝ : Type u_1
β : Type u_2
ι : Type u_3
α : Type u_4
inst✝¹ : NormedAddCommGroup α
inst✝ : CompleteSpace α
f : ℕ → α
l : ℝ
hl₁ : l < 1
hf : ∀ᶠ (n : ℕ) in atTop, f n ≠ 0
h : Tendsto (fun n => ‖f (n + 1)‖ / ‖f n‖) atTop (𝓝 l)
r : ℝ
hr₀ : l < r
hr₁ : r < 1
⊢ Summable f

tactic: refine summable_of_ratio_norm_eventually_le hr₁ ?_
state_before: case intro.intro
α✝ : Type u_1
β : Type u_2
ι : Type u_3
α : Type u_4
inst✝¹ : NormedAddCommGroup α
inst✝ : CompleteSpace α
f : ℕ → α
l : ℝ
hl₁ : l < 1
hf : ∀ᶠ (n : ℕ) in atTop, f n ≠ 0
h : Tendsto (fun n => ‖f (n + 1)‖ / ‖f n‖) atTop (𝓝 l)
r : ℝ
hr₀ : l < r
hr₁ : r < 1
⊢ Summable f
state_after: case intro.intro
α✝ : Type u_1
β : Type u_2
ι : Type u_3
α : Type u_4
inst✝¹ : NormedAddCommGroup α
inst✝ : CompleteSpace α
f : ℕ → α
l : ℝ
hl₁ : l < 1
hf : ∀ᶠ (n : ℕ) in atTop, f n ≠ 0
h : Tendsto (fun n => ‖f (n + 1)‖ / ‖f n‖) atTop (𝓝 l)
r : ℝ
hr₀ : l < r
hr₁ : r < 1
⊢ ∀ᶠ (n : ℕ) in atTop, ‖f (n + 1)‖ ≤ r * ‖f n‖

tactic: filter_upwards [eventually_le_of_tendsto_lt hr₀ h, hf] with _ _ h₁
state_before: case intro.intro
α✝ : Type u_1
β : Type u_2
ι : Type u_3
α : Type u_4
inst✝¹ : NormedAddCommGroup α
inst✝ : CompleteSpace α
f : ℕ → α
l : ℝ
hl₁ : l < 1
hf : ∀ᶠ (n : ℕ) in atTop, f n ≠ 0
h : Tendsto (fun n => ‖f (n + 1)‖ / ‖f n‖) atTop (𝓝 l)
r : ℝ
hr₀ : l < r
hr₁ : r < 1
⊢ ∀ᶠ (n : ℕ) in atTop, ‖f (n + 1)‖ ≤ r * ‖f n‖
state_after: case h
α✝ : Type u_1
β : Type u_2
ι : Type u_3
α : Type u_4
inst✝¹ : NormedAddCommGroup α
inst✝ : CompleteSpace α
f : ℕ → α
l : ℝ
hl₁ : l < 1
hf : ∀ᶠ (n : ℕ) in atTop, f n ≠ 0
h : Tendsto (fun n => ‖f (n + 1)‖ / ‖f n‖) atTop (𝓝 l)
r : ℝ
hr₀ : l < r
hr₁ : r < 1
a✝¹ : ℕ
a✝ : ‖f (a✝¹ + 1)‖ / ‖f a✝¹‖ ≤ r
h₁ : f a✝¹ ≠ 0
⊢ ‖f (a✝¹ + 1)‖ ≤ r * ‖f a✝¹‖

tactic: rwa [← div_le_iff (norm_pos_iff.mpr h₁)]
state_before: case h
α✝ : Type u_1
β : Type u_2
ι : Type u_3
α : Type u_4
inst✝¹ : NormedAddCommGroup α
inst✝ : CompleteSpace α
f : ℕ → α
l : ℝ
hl₁ : l < 1
hf : ∀ᶠ (n : ℕ) in atTop, f n ≠ 0
h : Tendsto (fun n => ‖f (n + 1)‖ / ‖f n‖) atTop (𝓝 l)
r : ℝ
hr₀ : l < r
hr₁ : r < 1
a✝¹ : ℕ
a✝ : ‖f (a✝¹ + 1)‖ / ‖f a✝¹‖ ≤ r
h₁ : f a✝¹ ≠ 0
⊢ ‖f (a✝¹ + 1)‖ ≤ r * ‖f a✝¹‖
state_after: no goals
Theorem: cfcₙ_apply_of_not_and_and
File: Mathlib/Topology/ContinuousFunction/NonUnitalFunctionalCalculus.lean

tactic: rw [cfcₙ_def, dif_neg ha]
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹² : CommSemiring R
inst✝¹¹ : Nontrivial R
inst✝¹⁰ : StarRing R
inst✝⁹ : MetricSpace R
inst✝⁸ : TopologicalSemiring R
inst✝⁷ : ContinuousStar R
inst✝⁶ : NonUnitalRing A
inst✝⁵ : StarRing A
inst✝⁴ : TopologicalSpace A
inst✝³ : Module R A
inst✝² : IsScalarTower R A A
inst✝¹ : SMulCommClass R A A
inst✝ : NonUnitalContinuousFunctionalCalculus R p
f✝ g : R → R
a✝ : A
hf : autoParam (ContinuousOn f✝ (σₙ R a✝)) _auto✝
hf0 : autoParam (f✝ 0 = 0) _auto✝
hg : autoParam (ContinuousOn g (σₙ R a✝)) _auto✝
hg0 : autoParam (g 0 = 0) _auto✝
ha✝ : autoParam (p a✝) _auto✝
f : R → R
a : A
ha : ¬(p a ∧ ContinuousOn f (σₙ R a) ∧ f 0 = 0)
⊢ cfcₙ f a = 0
state_after: no goals
Theorem: Function.Antiperiodic.int_mul_sub_eq
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [zsmul_eq_mul] using h.zsmul_sub_eq n
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Ring α
inst✝ : Ring β
h : Antiperiodic f c
n : ℤ
⊢ f (↑n * c - x) = ↑↑n.negOnePow * f (-x)
state_after: no goals
Theorem: Fin.lt_castPred_succ_iff
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [lt_castPred_iff, castSucc_lt_succ_iff]
state_before: n m : ℕ
a b : Fin (n + 1)
ha : a.succ ≠ last (n + 1)
⊢ b < a.succ.castPred ha ↔ b ≤ a
state_after: no goals
Theorem: Multiset.card_pi
File: Mathlib/Data/Multiset/Pi.lean

tactic: simp
state_before: α : Type u_1
inst✝ : DecidableEq α
β : α → Type u
δ : α → Sort v
m : Multiset α
t : (a : α) → Multiset (β a)
⊢ card (pi 0 t) = (map (fun a => card (t a)) 0).prod
state_after: no goals

tactic: simp (config := { contextual := true }) [mul_comm]
state_before: α : Type u_1
inst✝ : DecidableEq α
β : α → Type u
δ : α → Sort v
m : Multiset α
t : (a : α) → Multiset (β a)
⊢ ∀ (a : α) (s : Multiset α),
    card (s.pi t) = (map (fun a => card (t a)) s).prod →
      card ((a ::ₘ s).pi t) = (map (fun a => card (t a)) (a ::ₘ s)).prod
state_after: no goals
Theorem: EuclideanDomain.xgcdAux_val
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

tactic: rw [xgcd, ← xgcdAux_fst x y 1 0 0 1]
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
x y : R
⊢ xgcdAux x 1 0 y 0 1 = (gcd x y, xgcd x y)
state_after: no goals
Theorem: MeasureTheory.ae_uIoc_iff
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp only [uIoc_eq_union, mem_union, or_imp, eventually_and]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
inst✝ : LinearOrder α
a b : α
P : α → Prop
⊢ (∀ᵐ (x : α) ∂μ, x ∈ Ι a b → P x) ↔ (∀ᵐ (x : α) ∂μ, x ∈ Ioc a b → P x) ∧ ∀ᵐ (x : α) ∂μ, x ∈ Ioc b a → P x
state_after: no goals
Theorem: IsUnit.mul_div_cancel_left
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [mul_comm, h.mul_div_cancel_right]
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionCommMonoid α
a b✝ c d : α
h : IsUnit a
b : α
⊢ a * b / a = b
state_after: no goals
Theorem: MvPolynomial.coe_mul
File: Mathlib/RingTheory/MvPowerSeries/Basic.lean

tactic: classical
simp only [coeff_coe, MvPowerSeries.coeff_mul, coeff_mul]
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
φ ψ : MvPolynomial σ R
n : σ →₀ ℕ
⊢ (MvPowerSeries.coeff R n) ↑(φ * ψ) = (MvPowerSeries.coeff R n) (↑φ * ↑ψ)
state_after: no goals

tactic: simp only [coeff_coe, MvPowerSeries.coeff_mul, coeff_mul]
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
φ ψ : MvPolynomial σ R
n : σ →₀ ℕ
⊢ (MvPowerSeries.coeff R n) ↑(φ * ψ) = (MvPowerSeries.coeff R n) (↑φ * ↑ψ)
state_after: no goals
Theorem: nndist_pi_le_iff
File: Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean

tactic: simp [nndist_pi_def]
state_before: α : Type u_1
β : Type u_2
inst✝² : PseudoMetricSpace α
π : β → Type u_3
inst✝¹ : Fintype β
inst✝ : (b : β) → PseudoMetricSpace (π b)
f g : (b : β) → π b
r : ℝ≥0
⊢ nndist f g ≤ r ↔ ∀ (b : β), nndist (f b) (g b) ≤ r
state_after: no goals
Theorem: uniqueDiffWithinAt_Ioi
File: Mathlib/Analysis/Calculus/TangentCone.lean

tactic: simp
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
x y : E
s t : Set E
a : ℝ
⊢ (interior (Ioi a)).Nonempty
state_after: no goals

tactic: simp
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
x y : E
s t : Set E
a : ℝ
⊢ a ∈ closure (Ioi a)
state_after: no goals
Theorem: mul_ite
File: Mathlib/Algebra/Ring/Defs.lean

tactic: split_ifs <;> rfl
state_before: α✝ : Type u
β : Type v
γ : Type w
R : Type x
α : Type u_1
inst✝¹ : Mul α
P : Prop
inst✝ : Decidable P
a b c : α
⊢ (a * if P then b else c) = if P then a * b else a * c
state_after: no goals
Theorem: ENat.toNat_sub
File: Mathlib/Data/ENat/Basic.lean

tactic: lift n to ℕ using hn
state_before: m✝ n✝ n : ℕ∞
hn : n ≠ ⊤
m : ℕ∞
⊢ (m - n).toNat = m.toNat - n.toNat
state_after: case intro
m✝ n✝ m : ℕ∞
n : ℕ
⊢ (m - ↑n).toNat = m.toNat - (↑n).toNat

tactic: induction m
state_before: case intro
m✝ n✝ m : ℕ∞
n : ℕ
⊢ (m - ↑n).toNat = m.toNat - (↑n).toNat
state_after: case intro.top
m n✝ : ℕ∞
n : ℕ
⊢ (⊤ - ↑n).toNat = ⊤.toNat - (↑n).toNat

case intro.coe
m n✝ : ℕ∞
n a✝ : ℕ
⊢ (↑a✝ - ↑n).toNat = (↑a✝).toNat - (↑n).toNat

tactic: rw [top_sub_coe, toNat_top, zero_tsub]
state_before: case intro.top
m n✝ : ℕ∞
n : ℕ
⊢ (⊤ - ↑n).toNat = ⊤.toNat - (↑n).toNat
state_after: no goals

tactic: rw [← coe_sub, toNat_coe, toNat_coe, toNat_coe]
state_before: case intro.coe
m n✝ : ℕ∞
n a✝ : ℕ
⊢ (↑a✝ - ↑n).toNat = (↑a✝).toNat - (↑n).toNat
state_after: no goals
Theorem: Matrix.mem_unitaryGroup_iff'
File: Mathlib/LinearAlgebra/UnitaryGroup.lean

tactic: refine ⟨And.left, fun hA => ⟨hA, ?_⟩⟩
state_before: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
α : Type v
inst✝¹ : CommRing α
inst✝ : StarRing α
A : Matrix n n α
⊢ A ∈ unitaryGroup n α ↔ star A * A = 1
state_after: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
α : Type v
inst✝¹ : CommRing α
inst✝ : StarRing α
A : Matrix n n α
hA : star A * A = 1
⊢ A * star A = 1

tactic: rwa [mul_eq_one_comm] at hA
state_before: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
α : Type v
inst✝¹ : CommRing α
inst✝ : StarRing α
A : Matrix n n α
hA : star A * A = 1
⊢ A * star A = 1
state_after: no goals