1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: LipschitzWith.ae_differentiableAt
File: Mathlib/Analysis/Calculus/Rademacher.lean

tactic: rw [← lipschitzOn_univ] at h
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : FiniteDimensional ℝ E
inst✝⁵ : MeasurableSpace E
inst✝⁴ : BorelSpace E
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
C D : ℝ≥0
f✝ g : E → ℝ
s : Set E
μ : Measure E
inst✝¹ : μ.IsAddHaarMeasure
inst✝ : FiniteDimensional ℝ F
f : E → F
h : LipschitzWith C f
⊢ ∀ᵐ (x : E) ∂μ, DifferentiableAt ℝ f x
state_after: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : FiniteDimensional ℝ E
inst✝⁵ : MeasurableSpace E
inst✝⁴ : BorelSpace E
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
C D : ℝ≥0
f✝ g : E → ℝ
s : Set E
μ : Measure E
inst✝¹ : μ.IsAddHaarMeasure
inst✝ : FiniteDimensional ℝ F
f : E → F
h : LipschitzOnWith C f univ
⊢ ∀ᵐ (x : E) ∂μ, DifferentiableAt ℝ f x

tactic: simpa [differentiableWithinAt_univ] using h.ae_differentiableWithinAt_of_mem
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : FiniteDimensional ℝ E
inst✝⁵ : MeasurableSpace E
inst✝⁴ : BorelSpace E
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
C D : ℝ≥0
f✝ g : E → ℝ
s : Set E
μ : Measure E
inst✝¹ : μ.IsAddHaarMeasure
inst✝ : FiniteDimensional ℝ F
f : E → F
h : LipschitzOnWith C f univ
⊢ ∀ᵐ (x : E) ∂μ, DifferentiableAt ℝ f x
state_after: no goals
Theorem: Zsqrtd.hom_ext
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: ext ⟨x_re, x_im⟩
state_before: R : Type
inst✝ : Ring R
d : ℤ
f g : ℤ√d →+* R
h : f sqrtd = g sqrtd
⊢ f = g
state_after: case a.mk
R : Type
inst✝ : Ring R
d : ℤ
f g : ℤ√d →+* R
h : f sqrtd = g sqrtd
x_re x_im : ℤ
⊢ f { re := x_re, im := x_im } = g { re := x_re, im := x_im }

tactic: simp [decompose, h]
state_before: case a.mk
R : Type
inst✝ : Ring R
d : ℤ
f g : ℤ√d →+* R
h : f sqrtd = g sqrtd
x_re x_im : ℤ
⊢ f { re := x_re, im := x_im } = g { re := x_re, im := x_im }
state_after: no goals
Theorem: Polynomial.degree_intCast_le
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: simp
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Ring R
n : ℤ
⊢ (↑n).natDegree ≤ Zero.zero
state_after: no goals
Theorem: MeasureTheory.lintegral_eq_zero_of_isMulLeftInvariant
File: Mathlib/MeasureTheory/Group/LIntegral.lean

tactic: rw [lintegral_eq_zero_iff hf.measurable, hf.ae_eq_iff_eq μ continuous_zero]
state_before: G : Type u_1
inst✝⁷ : MeasurableSpace G
μ : Measure G
g : G
inst✝⁶ : TopologicalSpace G
inst✝⁵ : Group G
inst✝⁴ : TopologicalGroup G
inst✝³ : BorelSpace G
inst✝² : μ.IsMulLeftInvariant
inst✝¹ : μ.Regular
inst✝ : NeZero μ
f : G → ℝ≥0∞
hf : Continuous f
⊢ ∫⁻ (x : G), f x ∂μ = 0 ↔ f = 0
state_after: no goals
Theorem: Nat.NormDigits.digits_one
File: Mathlib/Data/Nat/Digits.lean

tactic: have b2 : 1 < b :=
  lt_iff_add_one_le.mpr (le_trans (add_le_add_right (lt_iff_add_one_le.mp n0) 1) nb)
state_before: n✝ b n : ℕ
n0 : 0 < n
nb : n < b
⊢ b.digits n = [n] ∧ 1 < b ∧ 0 < n
state_after: n✝ b n : ℕ
n0 : 0 < n
nb : n < b
b2 : 1 < b
⊢ b.digits n = [n] ∧ 1 < b ∧ 0 < n

tactic: refine ⟨?_, b2, n0⟩
state_before: n✝ b n : ℕ
n0 : 0 < n
nb : n < b
b2 : 1 < b
⊢ b.digits n = [n] ∧ 1 < b ∧ 0 < n
state_after: n✝ b n : ℕ
n0 : 0 < n
nb : n < b
b2 : 1 < b
⊢ b.digits n = [n]

tactic: rw [Nat.digits_def' b2 n0, Nat.mod_eq_of_lt nb,
  (Nat.div_eq_zero_iff ((zero_le n).trans_lt nb)).2 nb, Nat.digits_zero]
state_before: n✝ b n : ℕ
n0 : 0 < n
nb : n < b
b2 : 1 < b
⊢ b.digits n = [n]
state_after: no goals
Theorem: CategoryTheory.Limits.hasFiniteWidePullbacks_of_hasFiniteLimits
File: Mathlib/CategoryTheory/Limits/Shapes/FiniteLimits.lean

tactic: cases nonempty_fintype J
state_before: C : Type u
inst✝¹ : Category.{v, u} C
J✝ : Type v
inst✝ : HasFiniteLimits C
J : Type
x✝ : Finite J
⊢ HasLimitsOfShape (WidePullbackShape J) C
state_after: case intro
C : Type u
inst✝¹ : Category.{v, u} C
J✝ : Type v
inst✝ : HasFiniteLimits C
J : Type
x✝ : Finite J
val✝ : Fintype J
⊢ HasLimitsOfShape (WidePullbackShape J) C

tactic: exact HasFiniteLimits.out _
state_before: case intro
C : Type u
inst✝¹ : Category.{v, u} C
J✝ : Type v
inst✝ : HasFiniteLimits C
J : Type
x✝ : Finite J
val✝ : Fintype J
⊢ HasLimitsOfShape (WidePullbackShape J) C
state_after: no goals
Theorem: MeasureTheory.isStoppingTime_const
File: Mathlib/Probability/Process/Stopping.lean

tactic: simp only [MeasurableSet.const]
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : Preorder ι
f : Filtration ι m
i j : ι
⊢ MeasurableSet {ω | (fun x => i) ω ≤ j}
state_after: no goals
Theorem: Finset.fold_congr
File: Mathlib/Data/Finset/Fold.lean

tactic: rw [fold, fold, map_congr rfl H]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
op : β → β → β
hc : Std.Commutative op
ha : Std.Associative op
f : α → β
b : β
s : Finset α
a : α
g : α → β
H : ∀ x ∈ s, f x = g x
⊢ fold op b f s = fold op b g s
state_after: no goals
Theorem: Basis.ofEquivFun_equivFun
File: Mathlib/LinearAlgebra/Basis.lean

tactic: ext
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
inst✝ : Finite ι
v : Basis ι R M
⊢ (ofEquivFun v.equivFun).repr = v.repr
state_after: case h.h
ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
inst✝ : Finite ι
v : Basis ι R M
x✝ : M
a✝ : ι
⊢ ((ofEquivFun v.equivFun).repr x✝) a✝ = (v.repr x✝) a✝

tactic: rfl
state_before: case h.h
ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
inst✝ : Finite ι
v : Basis ι R M
x✝ : M
a✝ : ι
⊢ ((ofEquivFun v.equivFun).repr x✝) a✝ = (v.repr x✝) a✝
state_after: no goals
Theorem: FractionalIdeal.spanSingleton_mul_inv
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: rw [spanSingleton_inv, spanSingleton_mul_spanSingleton, mul_inv_cancel hx, spanSingleton_one]
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : CommRing A
inst✝⁷ : Field K
R₁ : Type u_4
inst✝⁶ : CommRing R₁
inst✝⁵ : IsDomain R₁
inst✝⁴ : Algebra R₁ K
inst✝³ : IsFractionRing R₁ K
I J : FractionalIdeal R₁⁰ K
K' : Type u_5
inst✝² : Field K'
inst✝¹ : Algebra R₁ K'
inst✝ : IsFractionRing R₁ K'
x : K
hx : x ≠ 0
⊢ spanSingleton R₁⁰ x * (spanSingleton R₁⁰ x)⁻¹ = 1
state_after: no goals
Theorem: dimH_bUnion
File: Mathlib/Topology/MetricSpace/HausdorffDimension.lean

tactic: haveI := hs.toEncodable
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
s : Set ι
hs : s.Countable
t : ι → Set X
⊢ dimH (⋃ i ∈ s, t i) = ⨆ i ∈ s, dimH (t i)
state_after: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
s : Set ι
hs : s.Countable
t : ι → Set X
this : Encodable ↑s
⊢ dimH (⋃ i ∈ s, t i) = ⨆ i ∈ s, dimH (t i)

tactic: rw [biUnion_eq_iUnion, dimH_iUnion, ← iSup_subtype'']
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
s : Set ι
hs : s.Countable
t : ι → Set X
this : Encodable ↑s
⊢ dimH (⋃ i ∈ s, t i) = ⨆ i ∈ s, dimH (t i)
state_after: no goals
Theorem: CategoryTheory.Preadditive.epi_of_cokernel_zero
File: Mathlib/CategoryTheory/Preadditive/Basic.lean

tactic: rw [← cokernel.π_desc f g h, w, Limits.zero_comp]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Preadditive C
P Q R : C
f✝ f' : P ⟶ Q
g✝ g' : Q ⟶ R
X Y : C
f : X ⟶ Y
inst✝ : HasColimit (parallelPair f 0)
w : cokernel.π f = 0
R✝ : C
g : Y ⟶ R✝
h : f ≫ g = 0
⊢ g = 0
state_after: no goals
Theorem: hasFDerivAt_jacobiTheta₂_term
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean

tactic: let f : ℂ × ℂ → ℂ := fun p ↦ 2 * π * I * n * p.1 + π * I * n ^ 2 * p.2
state_before: n : ℤ
z τ : ℂ
⊢ HasFDerivAt (fun p => jacobiTheta₂_term n p.1 p.2) (jacobiTheta₂_term_fderiv n z τ) (z, τ)
state_after: n : ℤ
z τ : ℂ
f : ℂ × ℂ → ℂ := fun p => 2 * ↑π * I * ↑n * p.1 + ↑π * I * ↑n ^ 2 * p.2
⊢ HasFDerivAt (fun p => jacobiTheta₂_term n p.1 p.2) (jacobiTheta₂_term_fderiv n z τ) (z, τ)

tactic: suffices HasFDerivAt f ((2 * π * I * n) • (ContinuousLinearMap.fst ℂ ℂ ℂ)
  + (π * I * n ^ 2) • (ContinuousLinearMap.snd ℂ ℂ ℂ)) (z, τ) from this.cexp
state_before: n : ℤ
z τ : ℂ
f : ℂ × ℂ → ℂ := fun p => 2 * ↑π * I * ↑n * p.1 + ↑π * I * ↑n ^ 2 * p.2
⊢ HasFDerivAt (fun p => jacobiTheta₂_term n p.1 p.2) (jacobiTheta₂_term_fderiv n z τ) (z, τ)
state_after: n : ℤ
z τ : ℂ
f : ℂ × ℂ → ℂ := fun p => 2 * ↑π * I * ↑n * p.1 + ↑π * I * ↑n ^ 2 * p.2
⊢ HasFDerivAt f ((2 * ↑π * I * ↑n) • ContinuousLinearMap.fst ℂ ℂ ℂ + (↑π * I * ↑n ^ 2) • ContinuousLinearMap.snd ℂ ℂ ℂ)
    (z, τ)

tactic: exact (hasFDerivAt_fst.const_mul _).add (hasFDerivAt_snd.const_mul _)
state_before: n : ℤ
z τ : ℂ
f : ℂ × ℂ → ℂ := fun p => 2 * ↑π * I * ↑n * p.1 + ↑π * I * ↑n ^ 2 * p.2
⊢ HasFDerivAt f ((2 * ↑π * I * ↑n) • ContinuousLinearMap.fst ℂ ℂ ℂ + (↑π * I * ↑n ^ 2) • ContinuousLinearMap.snd ℂ ℂ ℂ)
    (z, τ)
state_after: no goals
Theorem: edist_lt_ofReal
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

tactic: rw [edist_dist, ENNReal.ofReal_lt_ofReal_iff_of_nonneg dist_nonneg]
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y : α
r : ℝ
⊢ edist x y < ENNReal.ofReal r ↔ dist x y < r
state_after: no goals
Theorem: HomologicalComplex.dFrom_comp_xNextIso
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: simp [C.dFrom_eq r]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
i j : ι
r : c.Rel i j
⊢ C.dFrom i ≫ (C.xNextIso r).hom = C.d i j
state_after: no goals
Theorem: wbtw_or_wbtw_smul_vadd_of_nonneg
File: Mathlib/Analysis/Convex/Between.lean

tactic: rcases le_total r₁ r₂ with (h | h)
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x : P
v : V
r₁ r₂ : R
hr₁ : 0 ≤ r₁
hr₂ : 0 ≤ r₂
⊢ Wbtw R x (r₁ • v +ᵥ x) (r₂ • v +ᵥ x) ∨ Wbtw R x (r₂ • v +ᵥ x) (r₁ • v +ᵥ x)
state_after: case inl
R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x : P
v : V
r₁ r₂ : R
hr₁ : 0 ≤ r₁
hr₂ : 0 ≤ r₂
h : r₁ ≤ r₂
⊢ Wbtw R x (r₁ • v +ᵥ x) (r₂ • v +ᵥ x) ∨ Wbtw R x (r₂ • v +ᵥ x) (r₁ • v +ᵥ x)

case inr
R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x : P
v : V
r₁ r₂ : R
hr₁ : 0 ≤ r₁
hr₂ : 0 ≤ r₂
h : r₂ ≤ r₁
⊢ Wbtw R x (r₁ • v +ᵥ x) (r₂ • v +ᵥ x) ∨ Wbtw R x (r₂ • v +ᵥ x) (r₁ • v +ᵥ x)

tactic: exact Or.inl (wbtw_smul_vadd_smul_vadd_of_nonneg_of_le x v hr₁ h)
state_before: case inl
R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x : P
v : V
r₁ r₂ : R
hr₁ : 0 ≤ r₁
hr₂ : 0 ≤ r₂
h : r₁ ≤ r₂
⊢ Wbtw R x (r₁ • v +ᵥ x) (r₂ • v +ᵥ x) ∨ Wbtw R x (r₂ • v +ᵥ x) (r₁ • v +ᵥ x)
state_after: no goals

tactic: exact Or.inr (wbtw_smul_vadd_smul_vadd_of_nonneg_of_le x v hr₂ h)
state_before: case inr
R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x : P
v : V
r₁ r₂ : R
hr₁ : 0 ≤ r₁
hr₂ : 0 ≤ r₂
h : r₂ ≤ r₁
⊢ Wbtw R x (r₁ • v +ᵥ x) (r₂ • v +ᵥ x) ∨ Wbtw R x (r₂ • v +ᵥ x) (r₁ • v +ᵥ x)
state_after: no goals
Theorem: Finset.insert_union_comm
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [insert_union, union_insert]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t✝ u v : Finset α
a✝ b : α
s t : Finset α
a : α
⊢ insert a s ∪ t = s ∪ insert a t
state_after: no goals
Theorem: Int.natAbs_inj_of_nonneg_of_nonpos
File: Mathlib/Data/Int/Lemmas.lean

tactic: simpa only [Int.natAbs_neg] using natAbs_inj_of_nonneg_of_nonneg ha (neg_nonneg_of_nonpos hb)
state_before: a✝ b✝ : ℤ
n : ℕ
a b : ℤ
ha : 0 ≤ a
hb : b ≤ 0
⊢ a.natAbs = b.natAbs ↔ a = -b
state_after: no goals
Theorem: Multiset.rel_add_right
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [← rel_flip, rel_add_left]
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
r : α → β → Prop
p : γ → δ → Prop
as : Multiset α
bs₀ bs₁ : Multiset β
⊢ Rel r as (bs₀ + bs₁) ↔ ∃ as₀ as₁, Rel r as₀ bs₀ ∧ Rel r as₁ bs₁ ∧ as = as₀ + as₁
state_after: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
r : α → β → Prop
p : γ → δ → Prop
as : Multiset α
bs₀ bs₁ : Multiset β
⊢ (∃ bs₀_1 bs₁_1, Rel (flip r) bs₀ bs₀_1 ∧ Rel (flip r) bs₁ bs₁_1 ∧ as = bs₀_1 + bs₁_1) ↔
    ∃ as₀ as₁, Rel r as₀ bs₀ ∧ Rel r as₁ bs₁ ∧ as = as₀ + as₁

tactic: simp [rel_flip]
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
r : α → β → Prop
p : γ → δ → Prop
as : Multiset α
bs₀ bs₁ : Multiset β
⊢ (∃ bs₀_1 bs₁_1, Rel (flip r) bs₀ bs₀_1 ∧ Rel (flip r) bs₁ bs₁_1 ∧ as = bs₀_1 + bs₁_1) ↔
    ∃ as₀ as₁, Rel r as₀ bs₀ ∧ Rel r as₁ bs₁ ∧ as = as₀ + as₁
state_after: no goals
Theorem: List.Perm.append_right
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

tactic: induction p with
| nil => rfl
| cons _ _ ih => exact cons _ ih
| swap => exact swap ..
| trans _ _ ih₁ ih₂ => exact trans ih₁ ih₂
state_before: α : Type u_1
l₁ l₂ t₁ : List α
p : l₁ ~ l₂
⊢ l₁ ++ t₁ ~ l₂ ++ t₁
state_after: no goals

tactic: rfl
state_before: case nil
α : Type u_1
l₁ l₂ t₁ : List α
⊢ [] ++ t₁ ~ [] ++ t₁
state_after: no goals

tactic: exact cons _ ih
state_before: case cons
α : Type u_1
l₁ l₂ t₁ : List α
x✝ : α
l₁✝ l₂✝ : List α
a✝ : l₁✝ ~ l₂✝
ih : l₁✝ ++ t₁ ~ l₂✝ ++ t₁
⊢ x✝ :: l₁✝ ++ t₁ ~ x✝ :: l₂✝ ++ t₁
state_after: no goals

tactic: exact swap ..
state_before: case swap
α : Type u_1
l₁ l₂ t₁ : List α
x✝ y✝ : α
l✝ : List α
⊢ y✝ :: x✝ :: l✝ ++ t₁ ~ x✝ :: y✝ :: l✝ ++ t₁
state_after: no goals

tactic: exact trans ih₁ ih₂
state_before: case trans
α : Type u_1
l₁ l₂ t₁ l₁✝ l₂✝ l₃✝ : List α
a✝¹ : l₁✝ ~ l₂✝
a✝ : l₂✝ ~ l₃✝
ih₁ : l₁✝ ++ t₁ ~ l₂✝ ++ t₁
ih₂ : l₂✝ ++ t₁ ~ l₃✝ ++ t₁
⊢ l₁✝ ++ t₁ ~ l₃✝ ++ t₁
state_after: no goals
Theorem: norm_inf_le_add
File: Mathlib/Analysis/Normed/Order/Lattice.lean

tactic: have h : ‖x ⊓ y - 0 ⊓ 0‖ ≤ ‖x - 0‖ + ‖y - 0‖ := norm_inf_sub_inf_le_add_norm x y 0 0
state_before: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
x y : α
⊢ ‖x ⊓ y‖ ≤ ‖x‖ + ‖y‖
state_after: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
x y : α
h : ‖x ⊓ y - 0 ⊓ 0‖ ≤ ‖x - 0‖ + ‖y - 0‖
⊢ ‖x ⊓ y‖ ≤ ‖x‖ + ‖y‖

tactic: simpa only [inf_idem, sub_zero] using h
state_before: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
x y : α
h : ‖x ⊓ y - 0 ⊓ 0‖ ≤ ‖x - 0‖ + ‖y - 0‖
⊢ ‖x ⊓ y‖ ≤ ‖x‖ + ‖y‖
state_after: no goals
Theorem: List.cyclicPermutations_ne_nil
File: Mathlib/Data/List/Rotate.lean

tactic: simpa using congr_arg length h
state_before: α : Type u
l✝ l' : List α
a : α
l : List α
h : (a :: l).cyclicPermutations = []
⊢ False
state_after: no goals
Theorem: Cubic.C_mul_prod_X_sub_C_eq
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: simp only [toPoly, C_neg, C_add, C_mul]
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝¹ : Semiring R
inst✝ : CommRing S
w x y z : S
⊢ C w * (X - C x) * (X - C y) * (X - C z) =
    { a := w, b := w * -(x + y + z), c := w * (x * y + x * z + y * z), d := w * -(x * y * z) }.toPoly
state_after: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝¹ : Semiring R
inst✝ : CommRing S
w x y z : S
⊢ C w * (X - C x) * (X - C y) * (X - C z) =
    C w * X ^ 3 + C w * -(C x + C y + C z) * X ^ 2 + C w * (C x * C y + C x * C z + C y * C z) * X +
      C w * -(C x * C y * C z)

tactic: ring1
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝¹ : Semiring R
inst✝ : CommRing S
w x y z : S
⊢ C w * (X - C x) * (X - C y) * (X - C z) =
    C w * X ^ 3 + C w * -(C x + C y + C z) * X ^ 2 + C w * (C x * C y + C x * C z + C y * C z) * X +
      C w * -(C x * C y * C z)
state_after: no goals
Theorem: LinearIndependent.coe_range
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: simpa using i.comp _ (rangeSplitting_injective v)
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
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
i : LinearIndependent R v
⊢ LinearIndependent (ι := { x // x ∈ range v }) R Subtype.val
state_after: no goals
Theorem: Set.injOn_iff_pairwise_ne
File: Mathlib/Data/Set/Pairwise/Basic.lean

tactic: simp only [InjOn, Set.Pairwise, not_imp_not]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r p q : α → α → Prop
f g : ι → α
s✝ t u : Set α
a b : α
s : Set ι
⊢ InjOn f s ↔ s.Pairwise fun x x_1 => f x ≠ f x_1
state_after: no goals
Theorem: Units.mk_semiconjBy
File: Mathlib/Algebra/Group/Semiconj/Units.lean

tactic: unfold SemiconjBy
state_before: M : Type u_1
G : Type u_2
inst✝ : Monoid M
u : Mˣ
x : M
⊢ SemiconjBy (↑u) x (↑u * x * ↑u⁻¹)
state_after: M : Type u_1
G : Type u_2
inst✝ : Monoid M
u : Mˣ
x : M
⊢ ↑u * x = ↑u * x * ↑u⁻¹ * ↑u

tactic: rw [Units.inv_mul_cancel_right]
state_before: M : Type u_1
G : Type u_2
inst✝ : Monoid M
u : Mˣ
x : M
⊢ ↑u * x = ↑u * x * ↑u⁻¹ * ↑u
state_after: no goals
Theorem: Finset.coe_erase
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [and_comm, Set.mem_diff, Set.mem_singleton_iff, mem_coe]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b a : α
s : Finset α
x✝ : α
⊢ x✝ ≠ a ∧ x✝ ∈ s ↔ x✝ ∈ ↑s \ {a}
state_after: no goals
Theorem: CategoryTheory.NatTrans.CommShift.comm
File: Mathlib/CategoryTheory/Shift/CommShift.lean

tactic: apply comm'
state_before: C : Type u_1
D : Type u_2
E : Type u_3
J : Type u_4
inst✝¹⁵ : Category.{u_7, u_1} C
inst✝¹⁴ : Category.{u_6, u_2} D
inst✝¹³ : Category.{?u.101299, u_3} E
inst✝¹² : Category.{?u.101303, u_4} J
F₁ F₂ F₃ : C ⥤ D
τ : F₁ ⟶ F₂
τ' : F₂ ⟶ F₃
e : F₁ ≅ F₂
G G' : D ⥤ E
τ'' : G ⟶ G'
H : E ⥤ J
A : Type u_5
inst✝¹¹ : AddMonoid A
inst✝¹⁰ : HasShift C A
inst✝⁹ : HasShift D A
inst✝⁸ : HasShift E A
inst✝⁷ : HasShift J A
inst✝⁶ : F₁.CommShift A
inst✝⁵ : F₂.CommShift A
inst✝⁴ : F₃.CommShift A
inst✝³ : G.CommShift A
inst✝² : G'.CommShift A
inst✝¹ : H.CommShift A
inst✝ : CommShift τ A
a : A
⊢ (F₁.commShiftIso a).hom ≫ whiskerRight τ (shiftFunctor D a) =
    whiskerLeft (shiftFunctor C a) τ ≫ (F₂.commShiftIso a).hom
state_after: no goals
Theorem: Submodule.comap_subtype_eq_top
File: Mathlib/Algebra/Module/Submodule/Range.lean

tactic: rw [map_subtype_top]
state_before: R : Type u_1
R₂ : Type u_2
R₃ : Type u_3
K : Type u_4
K₂ : Type u_5
M : Type u_6
M₂ : Type u_7
M₃ : Type u_8
V : Type u_9
V₂ : Type u_10
inst✝⁷ : Semiring R
inst✝⁶ : Semiring R₂
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M
inst✝² : Module R₂ M₂
p✝ p'✝ : Submodule R M
q : Submodule R₂ M₂
τ₁₂ : R →+* R₂
F : Type u_11
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F τ₁₂ M M₂
p p' : Submodule R M
⊢ map p.subtype ⊤ ≤ p' ↔ p ≤ p'
state_after: no goals
Theorem: mem_segment_iff_wbtw
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [Wbtw, affineSegment_eq_segment]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z : V
⊢ y ∈ segment R x z ↔ Wbtw R x y z
state_after: no goals
Theorem: div_mul_le_div_mul_of_div_le_div
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [div_mul_eq_div_mul_one_div, div_mul_eq_div_mul_one_div]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : a / b ≤ c / d
he : 0 ≤ e
⊢ a / (b * e) ≤ c / (d * e)
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : a / b ≤ c / d
he : 0 ≤ e
⊢ a / b * (1 / e) ≤ c / d * (1 / e)

tactic: exact mul_le_mul_of_nonneg_right h (one_div_nonneg.2 he)
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : a / b ≤ c / d
he : 0 ≤ e
⊢ a / b * (1 / e) ≤ c / d * (1 / e)
state_after: no goals
Theorem: Real.Gamma_mul_Gamma_one_sub
File: Mathlib/Analysis/SpecialFunctions/Gamma/Beta.lean

tactic: simp_rw [← Complex.ofReal_inj, Complex.ofReal_div, Complex.ofReal_sin, Complex.ofReal_mul, ←
  Complex.Gamma_ofReal, Complex.ofReal_sub, Complex.ofReal_one]
state_before: s : ℝ
⊢ Gamma s * Gamma (1 - s) = π / sin (π * s)
state_after: s : ℝ
⊢ Complex.Gamma ↑s * Complex.Gamma (1 - ↑s) = ↑π / Complex.sin (↑π * ↑s)

tactic: exact Complex.Gamma_mul_Gamma_one_sub s
state_before: s : ℝ
⊢ Complex.Gamma ↑s * Complex.Gamma (1 - ↑s) = ↑π / Complex.sin (↑π * ↑s)
state_after: no goals
Theorem: MeasureTheory.integral_div_right_eq_self
File: Mathlib/MeasureTheory/Group/Integral.lean

tactic: simp_rw [div_eq_mul_inv]
state_before: 𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : μ.IsMulRightInvariant
f : G → E
g : G
⊢ ∫ (x : G), f (x / g) ∂μ = ∫ (x : G), f x ∂μ
state_after: 𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : μ.IsMulRightInvariant
f : G → E
g : G
⊢ ∫ (x : G), f (x * g⁻¹) ∂μ = ∫ (x : G), f x ∂μ

tactic: rw [integral_mul_right_eq_self f g⁻¹]
state_before: 𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : μ.IsMulRightInvariant
f : G → E
g : G
⊢ ∫ (x : G), f (x * g⁻¹) ∂μ = ∫ (x : G), f x ∂μ
state_after: no goals
Theorem: CategoryTheory.Limits.limitRightOpIsoOpColimit_hom_comp_ι
File: Mathlib/CategoryTheory/Limits/IndYoneda.lean

tactic: rw [← limitRightOpIsoOpColimit_inv_comp_π, ← Category.assoc, Iso.hom_inv_id, Category.id_comp]
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
I : Type v₁
inst✝¹ : Category.{v₂, v₁} I
F : Iᵒᵖ ⥤ C
inst✝ : HasColimit F
i : I
⊢ (limitRightOpIsoOpColimit F).hom ≫ (colimit.ι F { unop := i }).op = limit.π F.rightOp i
state_after: no goals
Theorem: LinearMap.dualCoannihilator_range_eq_ker_flip
File: Mathlib/LinearAlgebra/Dual.lean

tactic: ext x
state_before: R : Type u_1
M : Type u_2
M' : Type u_3
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
B : M →ₗ[R] M' →ₗ[R] R
⊢ (range B).dualCoannihilator = ker B.flip
state_after: case h
R : Type u_1
M : Type u_2
M' : Type u_3
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
B : M →ₗ[R] M' →ₗ[R] R
x : M'
⊢ x ∈ (range B).dualCoannihilator ↔ x ∈ ker B.flip

tactic: simp [ext_iff (f := B.flip x)]
state_before: case h
R : Type u_1
M : Type u_2
M' : Type u_3
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
B : M →ₗ[R] M' →ₗ[R] R
x : M'
⊢ x ∈ (range B).dualCoannihilator ↔ x ∈ ker B.flip
state_after: no goals