1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: LocallyLipschitz.iterate
File: Mathlib/Topology/EMetricSpace/Lipschitz.lean

tactic: simpa only [pow_zero] using LocallyLipschitz.id
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
f✝ : α → β
f : α → α
hf : LocallyLipschitz f
⊢ LocallyLipschitz f^[0]
state_after: no goals

tactic: rw [iterate_add, iterate_one]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
f✝ : α → β
f : α → α
hf : LocallyLipschitz f
n : ℕ
⊢ LocallyLipschitz f^[n + 1]
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
f✝ : α → β
f : α → α
hf : LocallyLipschitz f
n : ℕ
⊢ LocallyLipschitz (f^[n] ∘ f)

tactic: exact (hf.iterate n).comp hf
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
f✝ : α → β
f : α → α
hf : LocallyLipschitz f
n : ℕ
⊢ LocallyLipschitz (f^[n] ∘ f)
state_after: no goals
Theorem: Measurable.dite
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

tactic: simpa
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
inst✝ : (x : α) → Decidable (x ∈ s)
f : ↑s → β
hf : Measurable f
g : ↑sᶜ → β
hg : Measurable g
hs : MeasurableSet s
⊢ Measurable (s.restrict fun x => if hx : x ∈ s then f ⟨x, hx⟩ else g ⟨x, hx⟩)
state_after: no goals

tactic: simpa
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
inst✝ : (x : α) → Decidable (x ∈ s)
f : ↑s → β
hf : Measurable f
g : ↑sᶜ → β
hg : Measurable g
hs : MeasurableSet s
⊢ Measurable (sᶜ.restrict fun x => if hx : x ∈ s then f ⟨x, hx⟩ else g ⟨x, hx⟩)
state_after: no goals
Theorem: List.drop_tail
File: Mathlib/Data/List/Basic.lean

tactic: rw [← drop_drop, drop_one]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
n : ℕ
⊢ drop n l.tail = drop (n + 1) l
state_after: no goals
Theorem: PadicSeq.val_eq_iff_norm_eq
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: rw [norm_eq_pow_val hf, norm_eq_pow_val hg, ← neg_inj, zpow_inj]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
f g : PadicSeq p
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ f.valuation = g.valuation ↔ f.norm = g.norm
state_after: case h₀
p : ℕ
inst✝ : Fact (Nat.Prime p)
f g : PadicSeq p
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ 0 < ↑p

case h₁
p : ℕ
inst✝ : Fact (Nat.Prime p)
f g : PadicSeq p
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ ↑p ≠ 1

tactic: exact mod_cast (Fact.out : p.Prime).pos
state_before: case h₀
p : ℕ
inst✝ : Fact (Nat.Prime p)
f g : PadicSeq p
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ 0 < ↑p
state_after: no goals

tactic: exact mod_cast (Fact.out : p.Prime).ne_one
state_before: case h₁
p : ℕ
inst✝ : Fact (Nat.Prime p)
f g : PadicSeq p
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ ↑p ≠ 1
state_after: no goals
Theorem: CategoryTheory.preservesColimitsIso_inv_comp_desc
File: Mathlib/CategoryTheory/Limits/Preserves/Limits.lean

tactic: ext
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
inst✝² : Category.{w', w} J
F : J ⥤ C
inst✝¹ : PreservesColimit F G
inst✝ : HasColimit F
t : Cocone F
⊢ (preservesColimitIso G F).inv ≫ G.map (colimit.desc F t) = colimit.desc (F ⋙ G) (G.mapCocone t)
state_after: case w
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
inst✝² : Category.{w', w} J
F : J ⥤ C
inst✝¹ : PreservesColimit F G
inst✝ : HasColimit F
t : Cocone F
j✝ : J
⊢ colimit.ι (F ⋙ G) j✝ ≫ (preservesColimitIso G F).inv ≫ G.map (colimit.desc F t) =
    colimit.ι (F ⋙ G) j✝ ≫ colimit.desc (F ⋙ G) (G.mapCocone t)

tactic: simp [← G.map_comp]
state_before: case w
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
inst✝² : Category.{w', w} J
F : J ⥤ C
inst✝¹ : PreservesColimit F G
inst✝ : HasColimit F
t : Cocone F
j✝ : J
⊢ colimit.ι (F ⋙ G) j✝ ≫ (preservesColimitIso G F).inv ≫ G.map (colimit.desc F t) =
    colimit.ι (F ⋙ G) j✝ ≫ colimit.desc (F ⋙ G) (G.mapCocone t)
state_after: no goals
Theorem: star_le_iff
File: Mathlib/Algebra/Star/Order.lean

tactic: rw [← star_le_star_iff, star_star]
state_before: R : Type u
inst✝³ : NonUnitalSemiring R
inst✝² : PartialOrder R
inst✝¹ : StarRing R
inst✝ : StarOrderedRing R
x y : R
⊢ star x ≤ y ↔ x ≤ star y
state_after: no goals
Theorem: ContinuousLinearMap.norm_snd
File: Mathlib/Analysis/NormedSpace/OperatorNorm/Prod.lean

tactic: refine le_antisymm (norm_snd_le ..) ?_
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : SeminormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : Nontrivial F
⊢ ‖snd 𝕜 E F‖ = 1
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : SeminormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : Nontrivial F
⊢ 1 ≤ ‖snd 𝕜 E F‖

tactic: let ⟨f, hf⟩ := exists_ne (0 : F)
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : SeminormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : Nontrivial F
⊢ 1 ≤ ‖snd 𝕜 E F‖
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : SeminormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : Nontrivial F
f : F
hf : f ≠ 0
⊢ 1 ≤ ‖snd 𝕜 E F‖

tactic: have : ‖f‖ ≤ _ * max ‖(0 : E)‖ ‖f‖ := (snd 𝕜 E F).le_opNorm (0, f)
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : SeminormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : Nontrivial F
f : F
hf : f ≠ 0
⊢ 1 ≤ ‖snd 𝕜 E F‖
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : SeminormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : Nontrivial F
f : F
hf : f ≠ 0
this : ‖f‖ ≤ ‖snd 𝕜 E F‖ * max ‖0‖ ‖f‖
⊢ 1 ≤ ‖snd 𝕜 E F‖

tactic: rw [norm_zero, max_eq_right (norm_nonneg f)] at this
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : SeminormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : Nontrivial F
f : F
hf : f ≠ 0
this : ‖f‖ ≤ ‖snd 𝕜 E F‖ * max ‖0‖ ‖f‖
⊢ 1 ≤ ‖snd 𝕜 E F‖
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : SeminormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : Nontrivial F
f : F
hf : f ≠ 0
this : ‖f‖ ≤ ‖snd 𝕜 E F‖ * ‖f‖
⊢ 1 ≤ ‖snd 𝕜 E F‖

tactic: rwa [← mul_le_mul_iff_of_pos_right (norm_pos_iff.mpr hf), one_mul]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : SeminormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : Nontrivial F
f : F
hf : f ≠ 0
this : ‖f‖ ≤ ‖snd 𝕜 E F‖ * ‖f‖
⊢ 1 ≤ ‖snd 𝕜 E F‖
state_after: no goals
Theorem: TrivSqZeroExt.inv_one
File: Mathlib/Algebra/TrivSqZeroExt.lean

tactic: rw [← inl_one, TrivSqZeroExt.inv_inl, inv_one]
state_before: R : Type u
M : Type v
inst✝⁴ : DivisionSemiring R
inst✝³ : AddCommGroup M
inst✝² : Module Rᵐᵒᵖ M
inst✝¹ : Module R M
inst✝ : SMulCommClass R Rᵐᵒᵖ M
⊢ 1⁻¹ = 1
state_after: no goals
Theorem: Ordinal.mem_closed_iff_bsup
File: Mathlib/SetTheory/Ordinal/Topology.lean

tactic: rw [← mem_closure_iff_bsup, hs.closure_eq]
state_before: s : Set Ordinal.{u}
a : Ordinal.{u}
hs : IsClosed s
⊢ a ∈ s ↔ ∃ o, ∃ (_ : o ≠ 0), ∃ f, (∀ (i : Ordinal.{u}) (hi : i < o), f i hi ∈ s) ∧ o.bsup f = a
state_after: no goals
Theorem: Equiv.extendSubtype_mem
File: Mathlib/Logic/Equiv/Fintype.lean

tactic: convert (e ⟨x, hx⟩).2
state_before: α : Type u_1
β : Type u_2
inst✝² : Finite α
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
e : { x // p x } ≃ { x // q x }
x : α
hx : p x
⊢ q (e.extendSubtype x)
state_after: case h.e'_1
α : Type u_1
β : Type u_2
inst✝² : Finite α
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
e : { x // p x } ≃ { x // q x }
x : α
hx : p x
⊢ e.extendSubtype x = ↑(e ⟨x, hx⟩)

tactic: rw [e.extendSubtype_apply_of_mem _ hx]
state_before: case h.e'_1
α : Type u_1
β : Type u_2
inst✝² : Finite α
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
e : { x // p x } ≃ { x // q x }
x : α
hx : p x
⊢ e.extendSubtype x = ↑(e ⟨x, hx⟩)
state_after: no goals
Theorem: Polynomial.coeff_update_same
File: Mathlib/Algebra/Polynomial/Basic.lean

tactic: rw [p.coeff_update_apply, if_pos rfl]
state_before: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q p : R[X]
n : ℕ
a : R
⊢ (p.update n a).coeff n = a
state_after: no goals
Theorem: Metric.infDist_lt_iff
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: simp_rw [infDist, ← ENNReal.lt_ofReal_iff_toReal_lt (infEdist_ne_top hs), infEdist_lt_iff,
  ENNReal.lt_ofReal_iff_toReal_lt (edist_ne_top _ _), ← dist_edist]
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
r : ℝ
hs : s.Nonempty
⊢ infDist x s < r ↔ ∃ y ∈ s, dist x y < r
state_after: no goals
Theorem: FormalMultilinearSeries.order_zero
File: Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean

tactic: simp [order]
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
⊢ order 0 = 0
state_after: no goals
Theorem: MeasureTheory.SimpleFunc.mem_restrict_range
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: rw [← Finset.mem_coe, coe_range, coe_restrict _ hs, mem_range_indicator]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : MeasurableSpace α
K : Type u_5
inst✝ : Zero β
r : β
s : Set α
f : α →ₛ β
hs : MeasurableSet s
⊢ r ∈ (f.restrict s).range ↔ r = 0 ∧ s ≠ univ ∨ r ∈ ↑f '' s
state_after: no goals
Theorem: CliffordAlgebra.ofBaseChange_tmul_ι
File: Mathlib/LinearAlgebra/CliffordAlgebra/BaseChange.lean

tactic: show algebraMap _ _ z * ofBaseChangeAux A Q (ι Q v) = ι (Q.baseChange A) (z ⊗ₜ[R] v)
state_before: R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
z : A
v : V
⊢ (ofBaseChange A Q) (z ⊗ₜ[R] (ι Q) v) = (ι (QuadraticForm.baseChange A Q)) (z ⊗ₜ[R] v)
state_after: R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
z : A
v : V
⊢ (algebraMap A (CliffordAlgebra (QuadraticForm.baseChange A Q))) z * (ofBaseChangeAux A Q) ((ι Q) v) =
    (ι (QuadraticForm.baseChange A Q)) (z ⊗ₜ[R] v)

tactic: rw [ofBaseChangeAux_ι, ← Algebra.smul_def, ← map_smul, TensorProduct.smul_tmul', smul_eq_mul,
  mul_one]
state_before: R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
z : A
v : V
⊢ (algebraMap A (CliffordAlgebra (QuadraticForm.baseChange A Q))) z * (ofBaseChangeAux A Q) ((ι Q) v) =
    (ι (QuadraticForm.baseChange A Q)) (z ⊗ₜ[R] v)
state_after: no goals
Theorem: CliffordAlgebra.foldr'Aux_foldr'Aux
File: Mathlib/LinearAlgebra/CliffordAlgebra/Fold.lean

tactic: cases' x_fx with x fx
state_before: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
Q : QuadraticForm R M
f : M →ₗ[R] CliffordAlgebra Q × N →ₗ[R] N
hf : ∀ (m : M) (x : CliffordAlgebra Q) (fx : N), (f m) ((ι Q) m * x, (f m) (x, fx)) = Q m • fx
v : M
x_fx : CliffordAlgebra Q × N
⊢ ((foldr'Aux Q f) v) (((foldr'Aux Q f) v) x_fx) = Q v • x_fx
state_after: case mk
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
Q : QuadraticForm R M
f : M →ₗ[R] CliffordAlgebra Q × N →ₗ[R] N
hf : ∀ (m : M) (x : CliffordAlgebra Q) (fx : N), (f m) ((ι Q) m * x, (f m) (x, fx)) = Q m • fx
v : M
x : CliffordAlgebra Q
fx : N
⊢ ((foldr'Aux Q f) v) (((foldr'Aux Q f) v) (x, fx)) = Q v • (x, fx)

tactic: simp only [foldr'Aux_apply_apply]
state_before: case mk
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
Q : QuadraticForm R M
f : M →ₗ[R] CliffordAlgebra Q × N →ₗ[R] N
hf : ∀ (m : M) (x : CliffordAlgebra Q) (fx : N), (f m) ((ι Q) m * x, (f m) (x, fx)) = Q m • fx
v : M
x : CliffordAlgebra Q
fx : N
⊢ ((foldr'Aux Q f) v) (((foldr'Aux Q f) v) (x, fx)) = Q v • (x, fx)
state_after: case mk
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
Q : QuadraticForm R M
f : M →ₗ[R] CliffordAlgebra Q × N →ₗ[R] N
hf : ∀ (m : M) (x : CliffordAlgebra Q) (fx : N), (f m) ((ι Q) m * x, (f m) (x, fx)) = Q m • fx
v : M
x : CliffordAlgebra Q
fx : N
⊢ ((ι Q) v * ((ι Q) v * x), (f v) ((ι Q) v * x, (f v) (x, fx))) = Q v • (x, fx)

tactic: rw [← mul_assoc, ι_sq_scalar, ← Algebra.smul_def, hf, Prod.smul_mk]
state_before: case mk
R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
Q : QuadraticForm R M
f : M →ₗ[R] CliffordAlgebra Q × N →ₗ[R] N
hf : ∀ (m : M) (x : CliffordAlgebra Q) (fx : N), (f m) ((ι Q) m * x, (f m) (x, fx)) = Q m • fx
v : M
x : CliffordAlgebra Q
fx : N
⊢ ((ι Q) v * ((ι Q) v * x), (f v) ((ι Q) v * x, (f v) (x, fx))) = Q v • (x, fx)
state_after: no goals
Theorem: zpow_mono_left
File: Mathlib/Algebra/Order/Group/Basic.lean

tactic: rw [← one_le_div', ← div_zpow]
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : OrderedCommGroup α
m n : ℤ
a✝ b✝ : α
hn : 0 ≤ n
a b : α
hab : a ≤ b
⊢ (fun x => x ^ n) a ≤ (fun x => x ^ n) b
state_after: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : OrderedCommGroup α
m n : ℤ
a✝ b✝ : α
hn : 0 ≤ n
a b : α
hab : a ≤ b
⊢ 1 ≤ (b / a) ^ n

tactic: exact one_le_zpow (one_le_div'.2 hab) hn
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : OrderedCommGroup α
m n : ℤ
a✝ b✝ : α
hn : 0 ≤ n
a b : α
hab : a ≤ b
⊢ 1 ≤ (b / a) ^ n
state_after: no goals
Theorem: Polynomial.coeff_hermite
File: Mathlib/RingTheory/Polynomial/Hermite/Basic.lean

tactic: split_ifs with h
state_before: n k : ℕ
⊢ (hermite n).coeff k = if Even (n + k) then (-1) ^ ((n - k) / 2) * ↑(n - k - 1)‼ * ↑(n.choose k) else 0
state_after: case pos
n k : ℕ
h : Even (n + k)
⊢ (hermite n).coeff k = (-1) ^ ((n - k) / 2) * ↑(n - k - 1)‼ * ↑(n.choose k)

case neg
n k : ℕ
h : ¬Even (n + k)
⊢ (hermite n).coeff k = 0

tactic: exact coeff_hermite_of_even_add h
state_before: case pos
n k : ℕ
h : Even (n + k)
⊢ (hermite n).coeff k = (-1) ^ ((n - k) / 2) * ↑(n - k - 1)‼ * ↑(n.choose k)
state_after: no goals

tactic: exact coeff_hermite_of_odd_add (Nat.odd_iff_not_even.mpr h)
state_before: case neg
n k : ℕ
h : ¬Even (n + k)
⊢ (hermite n).coeff k = 0
state_after: no goals
Theorem: Matrix.PosSemidef.sqrt_mul_self
File: Mathlib/LinearAlgebra/Matrix/PosDef.lean

tactic: rw [← pow_two, sq_sqrt]
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : CommRing R
inst✝⁴ : PartialOrder R
inst✝³ : StarRing R
inst✝² : StarOrderedRing R
inst✝¹ : RCLike 𝕜
inst✝ : DecidableEq n
A : Matrix n n 𝕜
hA : A.PosSemidef
⊢ hA.sqrt * hA.sqrt = A
state_after: no goals
Theorem: LinearMap.toMatrix_adjoint
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: simp [toLin_conjTranspose]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝¹² : RCLike 𝕜
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : InnerProductSpace 𝕜 E
inst✝⁷ : InnerProductSpace 𝕜 F
inst✝⁶ : InnerProductSpace 𝕜 G
m : Type u_5
n : Type u_6
inst✝⁵ : Fintype m
inst✝⁴ : DecidableEq m
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : FiniteDimensional 𝕜 E
inst✝ : FiniteDimensional 𝕜 F
v₁ : OrthonormalBasis n 𝕜 E
v₂ : OrthonormalBasis m 𝕜 F
f : E →ₗ[𝕜] F
⊢ (toLin v₂.toBasis v₁.toBasis) ((toMatrix v₂.toBasis v₁.toBasis) (adjoint f)) =
    (toLin v₂.toBasis v₁.toBasis) ((toMatrix v₁.toBasis v₂.toBasis) f)ᴴ
state_after: no goals
Theorem: MeasureTheory.SignedMeasure.restrictNonposSeq_subset
File: Mathlib/MeasureTheory/Decomposition/SignedHahn.lean

tactic: rw [restrictNonposSeq]
state_before: case succ
α : Type u_1
β : Type u_2
inst✝³ : MeasurableSpace α
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
n✝ : ℕ
⊢ MeasureTheory.SignedMeasure.restrictNonposSeq s i (n✝ + 1) ⊆ i
state_after: case succ
α : Type u_1
β : Type u_2
inst✝³ : MeasurableSpace α
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
n✝ : ℕ
⊢ MeasureTheory.SignedMeasure.someExistsOneDivLT s
      (i \
        ⋃ k,
          ⋃ (H : k ≤ n✝),
            let_fun this := ⋯;
            MeasureTheory.SignedMeasure.restrictNonposSeq s i k) ⊆
    i

tactic: exact someExistsOneDivLT_subset'
state_before: case succ
α : Type u_1
β : Type u_2
inst✝³ : MeasurableSpace α
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
n✝ : ℕ
⊢ MeasureTheory.SignedMeasure.someExistsOneDivLT s
      (i \
        ⋃ k,
          ⋃ (H : k ≤ n✝),
            let_fun this := ⋯;
            MeasureTheory.SignedMeasure.restrictNonposSeq s i k) ⊆
    i
state_after: no goals
Theorem: WType.leftInverse_nat
File: Mathlib/Data/W/Constructions.lean

tactic: rw [toNat, ofNat]
state_before: f : Natβ Natα.zero → WType Natβ
⊢ ofNat (mk Natα.zero f).toNat = mk Natα.zero f
state_after: f : Natβ Natα.zero → WType Natβ
⊢ mk Natα.zero Empty.elim = mk Natα.zero f

tactic: congr
state_before: f : Natβ Natα.zero → WType Natβ
⊢ mk Natα.zero Empty.elim = mk Natα.zero f
state_after: case e_f
f : Natβ Natα.zero → WType Natβ
⊢ Empty.elim = f

tactic: ext x
state_before: case e_f
f : Natβ Natα.zero → WType Natβ
⊢ Empty.elim = f
state_after: case e_f.h
f : Natβ Natα.zero → WType Natβ
x : Empty
⊢ x.elim = f x

tactic: cases x
state_before: case e_f.h
f : Natβ Natα.zero → WType Natβ
x : Empty
⊢ x.elim = f x
state_after: no goals

tactic: simp only [toNat, ofNat, leftInverse_nat (f ()), mk.injEq, heq_eq_eq, true_and]
state_before: f : Natβ Natα.succ → WType Natβ
⊢ ofNat (mk Natα.succ f).toNat = mk Natα.succ f
state_after: f : Natβ Natα.succ → WType Natβ
⊢ (fun x => f ()) = f

tactic: rfl
state_before: f : Natβ Natα.succ → WType Natβ
⊢ (fun x => f ()) = f
state_after: no goals
Theorem: cfcHom_eq_of_continuous_of_map_id
File: Mathlib/Topology/ContinuousFunction/FunctionalCalculus.lean

tactic: rw [cfcHom_id ha, hφ₂]
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹⁰ : CommSemiring R
inst✝⁹ : StarRing R
inst✝⁸ : MetricSpace R
inst✝⁷ : TopologicalSemiring R
inst✝⁶ : ContinuousStar R
inst✝⁵ : TopologicalSpace A
inst✝⁴ : Ring A
inst✝³ : StarRing A
inst✝² : Algebra R A
inst✝¹ : ContinuousFunctionalCalculus R p
a : A
ha : p a
inst✝ : UniqueContinuousFunctionalCalculus R A
φ : C(↑(spectrum R a), R) →⋆ₐ[R] A
hφ₁ : Continuous ⇑φ
hφ₂ : φ (ContinuousMap.restrict (spectrum R a) (ContinuousMap.id R)) = a
⊢ (cfcHom ha) (ContinuousMap.restrict (spectrum R a) (ContinuousMap.id R)) =
    φ (ContinuousMap.restrict (spectrum R a) (ContinuousMap.id R))
state_after: no goals
Theorem: CategoryTheory.eqToHom_iso_hom_naturality
File: Mathlib/CategoryTheory/EqToHom.lean

tactic: simp [w]
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
f g : β → C
z : (b : β) → f b ≅ g b
j j' : β
w : j = j'
⊢ g j = g j'
state_after: no goals

tactic: simp [w]
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
f g : β → C
z : (b : β) → f b ≅ g b
j j' : β
w : j = j'
⊢ f j = f j'
state_after: no goals

tactic: cases w
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
f g : β → C
z : (b : β) → f b ≅ g b
j j' : β
w : j = j'
⊢ (z j).hom ≫ eqToHom ⋯ = eqToHom ⋯ ≫ (z j').hom
state_after: case refl
C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
f g : β → C
z : (b : β) → f b ≅ g b
j : β
⊢ (z j).hom ≫ eqToHom ⋯ = eqToHom ⋯ ≫ (z j).hom

tactic: simp
state_before: case refl
C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
f g : β → C
z : (b : β) → f b ≅ g b
j : β
⊢ (z j).hom ≫ eqToHom ⋯ = eqToHom ⋯ ≫ (z j).hom
state_after: no goals
Theorem: TendstoUniformly.tendstoUniformlyOnFilter
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: rwa [← tendstoUniformly_iff_tendstoUniformlyOnFilter]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
h : TendstoUniformly F f p
⊢ TendstoUniformlyOnFilter F f p ⊤
state_after: no goals
Theorem: List.join_eq_nil
File: Mathlib/Data/List/Join.lean

tactic: simp only [join, append_eq_nil, join_eq_nil, forall_mem_cons]
state_before: α : Type u_1
β : Type u_2
l : List α
L : List (List α)
⊢ (l :: L).join = [] ↔ ∀ (l_1 : List α), l_1 ∈ l :: L → l_1 = []
state_after: no goals
Theorem: AlgebraicGeometry.PresheafedSpace.id_c_app
File: Mathlib/Geometry/RingedSpace/PresheafedSpace.lean

tactic: rw [id_c, map_id]
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
U : (Opens ↑↑X)ᵒᵖ
⊢ (𝟙 X).c.app U = X.presheaf.map (𝟙 U)
state_after: C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
U : (Opens ↑↑X)ᵒᵖ
⊢ (𝟙 X.presheaf).app U = 𝟙 (X.presheaf.obj U)

tactic: rfl
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
U : (Opens ↑↑X)ᵒᵖ
⊢ (𝟙 X.presheaf).app U = 𝟙 (X.presheaf.obj U)
state_after: no goals
Theorem: Set.preimage_eq
File: Mathlib/Data/Rel.lean

tactic: simp [Set.preimage, Rel.preimage, Rel.inv, flip, Rel.image]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
s : Set β
⊢ f ⁻¹' s = (Function.graph f).preimage s
state_after: no goals
Theorem: support_finRotate
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: ext
state_before: n : ℕ
⊢ (finRotate (n + 2)).support = Finset.univ
state_after: case a
n : ℕ
a✝ : Fin (n + 2)
⊢ a✝ ∈ (finRotate (n + 2)).support ↔ a✝ ∈ Finset.univ

tactic: simp
state_before: case a
n : ℕ
a✝ : Fin (n + 2)
⊢ a✝ ∈ (finRotate (n + 2)).support ↔ a✝ ∈ Finset.univ
state_after: no goals
Theorem: Aesop.Array.size_modify
File: .lake/packages/aesop/Aesop/Util/Basic.lean

tactic: simp only [Array.modify, Id.run, Array.modifyM]
state_before: α : Type u_1
a : Array α
i : Nat
f : α → α
⊢ (a.modify i f).size = a.size
state_after: α : Type u_1
a : Array α
i : Nat
f : α → α
⊢ Array.size
      (if h : i < a.size then do
        let v ← f (a.get ⟨i, ⋯⟩)
        pure (a.set ⟨i, ⋯⟩ v)
      else pure a) =
    a.size

tactic: split <;> simp
state_before: α : Type u_1
a : Array α
i : Nat
f : α → α
⊢ Array.size
      (if h : i < a.size then do
        let v ← f (a.get ⟨i, ⋯⟩)
        pure (a.set ⟨i, ⋯⟩ v)
      else pure a) =
    a.size
state_after: no goals
Theorem: ZNum.cast_lt
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← cast_to_int m, ← cast_to_int n, Int.cast_lt, lt_to_int]
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
m n : ZNum
⊢ ↑m < ↑n ↔ m < n
state_after: no goals