1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: IsLocalizedModule.mk'_smul
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: delta mk'
state_before: R : Type u_1
inst✝¹² : CommSemiring R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : AddCommMonoid M''
A : Type u_5
inst✝⁸ : CommSemiring A
inst✝⁷ : Algebra R A
inst✝⁶ : Module A M'
inst✝⁵ : IsLocalization S A
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M''
inst✝¹ : IsScalarTower R A M'
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
r : R
m : M
s : ↥S
⊢ mk' f (r • m) s = r • mk' f m s
state_after: R : Type u_1
inst✝¹² : CommSemiring R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : AddCommMonoid M''
A : Type u_5
inst✝⁸ : CommSemiring A
inst✝⁷ : Algebra R A
inst✝⁶ : Module A M'
inst✝⁵ : IsLocalization S A
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M''
inst✝¹ : IsScalarTower R A M'
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
r : R
m : M
s : ↥S
⊢ (fromLocalizedModule S f) (LocalizedModule.mk (r • m) s) = r • (fromLocalizedModule S f) (LocalizedModule.mk m s)

tactic: rw [← LocalizedModule.smul'_mk, LinearMap.map_smul]
state_before: R : Type u_1
inst✝¹² : CommSemiring R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : AddCommMonoid M''
A : Type u_5
inst✝⁸ : CommSemiring A
inst✝⁷ : Algebra R A
inst✝⁶ : Module A M'
inst✝⁵ : IsLocalization S A
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M''
inst✝¹ : IsScalarTower R A M'
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
r : R
m : M
s : ↥S
⊢ (fromLocalizedModule S f) (LocalizedModule.mk (r • m) s) = r • (fromLocalizedModule S f) (LocalizedModule.mk m s)
state_after: no goals
Theorem: EMetric.diam_iUnion_mem_option
File: Mathlib/Topology/EMetricSpace/Basic.lean

tactic: cases o <;> simp
state_before: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s✝ t : Set α
ι : Type u_2
o : Option ι
s : ι → Set α
⊢ diam (⋃ i ∈ o, s i) = ⨆ i ∈ o, diam (s i)
state_after: no goals
Theorem: Set.compl_section_ordSeparatingSet_mem_nhds
File: Mathlib/Topology/Order/T5.lean

tactic: rw [← nhds_left_sup_nhds_right, mem_sup]
state_before: X : Type u_1
inst✝² : LinearOrder X
inst✝¹ : TopologicalSpace X
inst✝ : OrderTopology X
a b c : X
s t : Set X
hd : Disjoint s (closure t)
ha : a ∈ s
⊢ (s.ordSeparatingSet t).ordConnectedSectionᶜ ∈ 𝓝 a
state_after: X : Type u_1
inst✝² : LinearOrder X
inst✝¹ : TopologicalSpace X
inst✝ : OrderTopology X
a b c : X
s t : Set X
hd : Disjoint s (closure t)
ha : a ∈ s
⊢ (s.ordSeparatingSet t).ordConnectedSectionᶜ ∈ 𝓝[≤] a ∧ (s.ordSeparatingSet t).ordConnectedSectionᶜ ∈ 𝓝[≥] a

tactic: exact
  ⟨compl_section_ordSeparatingSet_mem_nhdsWithin_Iic hd ha,
    compl_section_ordSeparatingSet_mem_nhdsWithin_Ici hd ha⟩
state_before: X : Type u_1
inst✝² : LinearOrder X
inst✝¹ : TopologicalSpace X
inst✝ : OrderTopology X
a b c : X
s t : Set X
hd : Disjoint s (closure t)
ha : a ∈ s
⊢ (s.ordSeparatingSet t).ordConnectedSectionᶜ ∈ 𝓝[≤] a ∧ (s.ordSeparatingSet t).ordConnectedSectionᶜ ∈ 𝓝[≥] a
state_after: no goals
Theorem: Complex.angle_eq_abs_arg
File: Mathlib/Analysis/Complex/Angle.lean

tactic: refine Real.arccos_eq_of_eq_cos (abs_nonneg _) (abs_arg_le_pi _) ?_
state_before: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ angle x y = |(x / y).arg|
state_after: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ ⟪x, y⟫_ℝ / (‖x‖ * ‖y‖) = Real.cos |(x / y).arg|

tactic: rw [Real.cos_abs, Complex.cos_arg (div_ne_zero hx hy)]
state_before: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ ⟪x, y⟫_ℝ / (‖x‖ * ‖y‖) = Real.cos |(x / y).arg|
state_after: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ ⟪x, y⟫_ℝ / (‖x‖ * ‖y‖) = (x / y).re / abs (x / y)

tactic: have := (map_ne_zero Complex.abs).2 hx
state_before: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ ⟪x, y⟫_ℝ / (‖x‖ * ‖y‖) = (x / y).re / abs (x / y)
state_after: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
this : abs x ≠ 0
⊢ ⟪x, y⟫_ℝ / (‖x‖ * ‖y‖) = (x / y).re / abs (x / y)

tactic: have := (map_ne_zero Complex.abs).2 hy
state_before: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
this : abs x ≠ 0
⊢ ⟪x, y⟫_ℝ / (‖x‖ * ‖y‖) = (x / y).re / abs (x / y)
state_after: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
this✝ : abs x ≠ 0
this : abs y ≠ 0
⊢ ⟪x, y⟫_ℝ / (‖x‖ * ‖y‖) = (x / y).re / abs (x / y)

tactic: simp [div_eq_mul_inv, Complex.normSq_eq_norm_sq]
state_before: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
this✝ : abs x ≠ 0
this : abs y ≠ 0
⊢ ⟪x, y⟫_ℝ / (‖x‖ * ‖y‖) = (x / y).re / abs (x / y)
state_after: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
this✝ : abs x ≠ 0
this : abs y ≠ 0
⊢ (x.re * y.re + x.im * y.im) * ((abs y)⁻¹ * (abs x)⁻¹) =
    (x.re * (y.re * (abs y ^ 2)⁻¹) + x.im * (y.im * (abs y ^ 2)⁻¹)) * (abs y * (abs x)⁻¹)

tactic: field_simp
state_before: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
this✝ : abs x ≠ 0
this : abs y ≠ 0
⊢ (x.re * y.re + x.im * y.im) * ((abs y)⁻¹ * (abs x)⁻¹) =
    (x.re * (y.re * (abs y ^ 2)⁻¹) + x.im * (y.im * (abs y ^ 2)⁻¹)) * (abs y * (abs x)⁻¹)
state_after: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
this✝ : abs x ≠ 0
this : abs y ≠ 0
⊢ (x.re * y.re + x.im * y.im) * (abs y ^ 2 * abs x) = (x.re * y.re + x.im * y.im) * abs y * (abs y * abs x)

tactic: ring
state_before: a x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
this✝ : abs x ≠ 0
this : abs y ≠ 0
⊢ (x.re * y.re + x.im * y.im) * (abs y ^ 2 * abs x) = (x.re * y.re + x.im * y.im) * abs y * (abs y * abs x)
state_after: no goals
Theorem: Filter.set_eventuallyLE_iff_inf_principal_le
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [le_inf_iff, inf_le_left, true_and_iff, le_principal_iff]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l✝ : Filter α
s t : Set α
l : Filter α
⊢ t ∈ l ⊓ 𝓟 s ↔ l ⊓ 𝓟 s ≤ l ⊓ 𝓟 t
state_after: no goals
Theorem: Function.Involutive.exists_mem_and_apply_eq_iff
File: Mathlib/Data/List/Basic.lean

tactic: rintro ⟨y, h, rfl⟩
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → α
hf : Involutive f
x : α
l : List α
⊢ (∃ y, y ∈ l ∧ f y = x) → f x ∈ l
state_after: case intro.intro
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → α
hf : Involutive f
l : List α
y : α
h : y ∈ l
⊢ f (f y) ∈ l

tactic: rwa [hf y]
state_before: case intro.intro
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → α
hf : Involutive f
l : List α
y : α
h : y ∈ l
⊢ f (f y) ∈ l
state_after: no goals
Theorem: Polynomial.support_toSubring
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: ext i
state_before: R : Type u
S : Type u_1
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑p.coeffs ⊆ ↑T
⊢ (p.toSubring T hp).support = p.support
state_after: case a
R : Type u
S : Type u_1
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑p.coeffs ⊆ ↑T
i : ℕ
⊢ i ∈ (p.toSubring T hp).support ↔ i ∈ p.support

tactic: simp only [mem_support_iff, not_iff_not, Ne]
state_before: case a
R : Type u
S : Type u_1
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑p.coeffs ⊆ ↑T
i : ℕ
⊢ i ∈ (p.toSubring T hp).support ↔ i ∈ p.support
state_after: case a
R : Type u
S : Type u_1
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑p.coeffs ⊆ ↑T
i : ℕ
⊢ (p.toSubring T hp).coeff i = 0 ↔ p.coeff i = 0

tactic: conv_rhs => rw [← coeff_toSubring p T hp]
state_before: case a
R : Type u
S : Type u_1
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑p.coeffs ⊆ ↑T
i : ℕ
⊢ (p.toSubring T hp).coeff i = 0 ↔ p.coeff i = 0
state_after: case a
R : Type u
S : Type u_1
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑p.coeffs ⊆ ↑T
i : ℕ
⊢ (p.toSubring T hp).coeff i = 0 ↔ ↑((p.toSubring T hp).coeff i) = 0

tactic: exact ⟨fun H => by rw [H, ZeroMemClass.coe_zero], fun H => Subtype.coe_injective H⟩
state_before: case a
R : Type u
S : Type u_1
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑p.coeffs ⊆ ↑T
i : ℕ
⊢ (p.toSubring T hp).coeff i = 0 ↔ ↑((p.toSubring T hp).coeff i) = 0
state_after: no goals

tactic: rw [H, ZeroMemClass.coe_zero]
state_before: R : Type u
S : Type u_1
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑p.coeffs ⊆ ↑T
i : ℕ
H : (p.toSubring T hp).coeff i = 0
⊢ ↑((p.toSubring T hp).coeff i) = 0
state_after: no goals
Theorem: List.length_eq_length_filter_add
File: Mathlib/Data/List/Basic.lean

tactic: simp_rw [← List.countP_eq_length_filter, l.length_eq_countP_add_countP f, Bool.not_eq_true,
  Bool.decide_eq_false]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
f : α → Bool
⊢ l.length = (filter f l).length + (filter (fun x => !f x) l).length
state_after: no goals
Theorem: Finpartition.exists_subset_part_bijOn
File: Mathlib/Order/Partition/Finpartition.lean

tactic: obtain ⟨r, hrs, hr⟩ := P.part_surjOn.exists_bijOn_subset
state_before: α : Type u_1
inst✝ : DecidableEq α
s t u : Finset α
P : Finpartition s
a : α
⊢ ∃ r ⊆ s, Set.BijOn P.part ↑r ↑P.parts
state_after: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
s t u : Finset α
P : Finpartition s
a : α
r : Set α
hrs : r ⊆ ↑s
hr : Set.BijOn P.part r ↑P.parts
⊢ ∃ r ⊆ s, Set.BijOn P.part ↑r ↑P.parts

tactic: lift r to Finset α using s.finite_toSet.subset hrs
state_before: case intro.intro
α : Type u_1
inst✝ : DecidableEq α
s t u : Finset α
P : Finpartition s
a : α
r : Set α
hrs : r ⊆ ↑s
hr : Set.BijOn P.part r ↑P.parts
⊢ ∃ r ⊆ s, Set.BijOn P.part ↑r ↑P.parts
state_after: case intro.intro.intro
α : Type u_1
inst✝ : DecidableEq α
s t u : Finset α
P : Finpartition s
a : α
r : Finset α
hrs : ↑r ⊆ ↑s
hr : Set.BijOn P.part ↑r ↑P.parts
⊢ ∃ r ⊆ s, Set.BijOn P.part ↑r ↑P.parts

tactic: exact ⟨r, mod_cast hrs, hr⟩
state_before: case intro.intro.intro
α : Type u_1
inst✝ : DecidableEq α
s t u : Finset α
P : Finpartition s
a : α
r : Finset α
hrs : ↑r ⊆ ↑s
hr : Set.BijOn P.part ↑r ↑P.parts
⊢ ∃ r ⊆ s, Set.BijOn P.part ↑r ↑P.parts
state_after: no goals
Theorem: hnot_inf_distrib
File: Mathlib/Order/Heyting/Basic.lean

tactic: simp_rw [← top_sdiff', sdiff_inf_distrib]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : CoheytingAlgebra α
a✝ b✝ c a b : α
⊢ ￢(a ⊓ b) = ￢a ⊔ ￢b
state_after: no goals
Theorem: FormalMultilinearSeries.coeff_eq_zero
File: Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean

tactic: rw [← mkPiRing_coeff_eq p, ContinuousMultilinearMap.mkPiRing_eq_zero_iff]
state_before: 𝕜 : Type u
𝕜' : Type u'
E : Type v
F : Type w
G : Type x
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p : FormalMultilinearSeries 𝕜 𝕜 E
f : 𝕜 → E
n : ℕ
z z₀ : 𝕜
y : Fin n → 𝕜
⊢ p.coeff n = 0 ↔ p n = 0
state_after: no goals
Theorem: Cycle.forall_eq_of_chain
File: Mathlib/Data/List/Cycle.lean

tactic: rw [chain_iff_pairwise] at hs
state_before: α : Type u_1
r : α → α → Prop
s : Cycle α
inst✝¹ : IsTrans α r
inst✝ : IsAntisymm α r
hs : Chain r s
a b : α
ha : a ∈ s
hb : b ∈ s
⊢ a = b
state_after: α : Type u_1
r : α → α → Prop
s : Cycle α
inst✝¹ : IsTrans α r
inst✝ : IsAntisymm α r
hs : ∀ a ∈ s, ∀ b ∈ s, r a b
a b : α
ha : a ∈ s
hb : b ∈ s
⊢ a = b

tactic: exact antisymm (hs a ha b hb) (hs b hb a ha)
state_before: α : Type u_1
r : α → α → Prop
s : Cycle α
inst✝¹ : IsTrans α r
inst✝ : IsAntisymm α r
hs : ∀ a ∈ s, ∀ b ∈ s, r a b
a b : α
ha : a ∈ s
hb : b ∈ s
⊢ a = b
state_after: no goals
Theorem: Matrix.kroneckerMap_diagonal_right
File: Mathlib/Data/Matrix/Kronecker.lean

tactic: ext ⟨i₁, i₂⟩ ⟨j₁, j₂⟩
state_before: R : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
β' : Type u_5
γ : Type u_6
γ' : Type u_7
l : Type u_8
m : Type u_9
n : Type u_10
p : Type u_11
q : Type u_12
r : Type u_13
l' : Type u_14
m' : Type u_15
n' : Type u_16
p' : Type u_17
inst✝² : Zero β
inst✝¹ : Zero γ
inst✝ : DecidableEq n
f : α → β → γ
hf : ∀ (a : α), f a 0 = 0
A : Matrix l m α
b : n → β
⊢ kroneckerMap f A (diagonal b) = blockDiagonal fun i => A.map fun a => f a (b i)
state_after: case a.mk.mk
R : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
β' : Type u_5
γ : Type u_6
γ' : Type u_7
l : Type u_8
m : Type u_9
n : Type u_10
p : Type u_11
q : Type u_12
r : Type u_13
l' : Type u_14
m' : Type u_15
n' : Type u_16
p' : Type u_17
inst✝² : Zero β
inst✝¹ : Zero γ
inst✝ : DecidableEq n
f : α → β → γ
hf : ∀ (a : α), f a 0 = 0
A : Matrix l m α
b : n → β
i₁ : l
i₂ : n
j₁ : m
j₂ : n
⊢ kroneckerMap f A (diagonal b) (i₁, i₂) (j₁, j₂) = blockDiagonal (fun i => A.map fun a => f a (b i)) (i₁, i₂) (j₁, j₂)

tactic: simp [diagonal, blockDiagonal, apply_ite (f (A i₁ j₁)), hf]
state_before: case a.mk.mk
R : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
β' : Type u_5
γ : Type u_6
γ' : Type u_7
l : Type u_8
m : Type u_9
n : Type u_10
p : Type u_11
q : Type u_12
r : Type u_13
l' : Type u_14
m' : Type u_15
n' : Type u_16
p' : Type u_17
inst✝² : Zero β
inst✝¹ : Zero γ
inst✝ : DecidableEq n
f : α → β → γ
hf : ∀ (a : α), f a 0 = 0
A : Matrix l m α
b : n → β
i₁ : l
i₂ : n
j₁ : m
j₂ : n
⊢ kroneckerMap f A (diagonal b) (i₁, i₂) (j₁, j₂) = blockDiagonal (fun i => A.map fun a => f a (b i)) (i₁, i₂) (j₁, j₂)
state_after: no goals
Theorem: FP.Float.Zero.valid
File: Mathlib/Data/FP/Basic.lean

tactic: rw [add_sub_assoc]
state_before: C : FloatCfg
⊢ emin ≤ emin + ↑prec - 1
state_after: C : FloatCfg
⊢ emin ≤ emin + (↑prec - 1)

tactic: apply le_add_of_nonneg_right
state_before: C : FloatCfg
⊢ emin ≤ emin + (↑prec - 1)
state_after: case h
C : FloatCfg
⊢ 0 ≤ ↑prec - 1

tactic: apply sub_nonneg_of_le
state_before: case h
C : FloatCfg
⊢ 0 ≤ ↑prec - 1
state_after: case h.a
C : FloatCfg
⊢ 1 ≤ ↑prec

tactic: apply Int.ofNat_le_ofNat_of_le
state_before: case h.a
C : FloatCfg
⊢ 1 ≤ ↑prec
state_after: case h.a.a
C : FloatCfg
⊢ 1 ≤ prec

tactic: exact C.precPos
state_before: case h.a.a
C : FloatCfg
⊢ 1 ≤ prec
state_after: no goals

tactic: rw [← Int.ofNat_le] at this
state_before: C : FloatCfg
this : prec ≤ 2 * emax
⊢ emin + ↑prec - 1 ≤ ↑emax
state_after: C : FloatCfg
this : ↑prec ≤ ↑(2 * emax)
⊢ emin + ↑prec - 1 ≤ ↑emax

tactic: rw [← sub_nonneg] at *
state_before: C : FloatCfg
this : ↑prec ≤ ↑(2 * emax)
⊢ emin + ↑prec - 1 ≤ ↑emax
state_after: C : FloatCfg
this : 0 ≤ ↑(2 * emax) - ↑prec
⊢ 0 ≤ ↑emax - (emin + ↑prec - 1)

tactic: simp only [emin, emax] at *
state_before: C : FloatCfg
this : 0 ≤ ↑(2 * emax) - ↑prec
⊢ 0 ≤ ↑emax - (emin + ↑prec - 1)
state_after: C : FloatCfg
this : 0 ≤ ↑(2 * FloatCfg.emax) - ↑prec
⊢ 0 ≤ ↑FloatCfg.emax - (1 - ↑FloatCfg.emax + ↑prec - 1)

tactic: ring_nf
state_before: C : FloatCfg
this : 0 ≤ ↑(2 * FloatCfg.emax) - ↑prec
⊢ 0 ≤ ↑FloatCfg.emax - (1 - ↑FloatCfg.emax + ↑prec - 1)
state_after: C : FloatCfg
this : 0 ≤ ↑(2 * FloatCfg.emax) - ↑prec
⊢ 0 ≤ ↑FloatCfg.emax * 2 - ↑prec

tactic: rw [mul_comm]
state_before: C : FloatCfg
this : 0 ≤ ↑(2 * FloatCfg.emax) - ↑prec
⊢ 0 ≤ ↑FloatCfg.emax * 2 - ↑prec
state_after: C : FloatCfg
this : 0 ≤ ↑(2 * FloatCfg.emax) - ↑prec
⊢ 0 ≤ 2 * ↑FloatCfg.emax - ↑prec

tactic: assumption
state_before: C : FloatCfg
this : 0 ≤ ↑(2 * FloatCfg.emax) - ↑prec
⊢ 0 ≤ 2 * ↑FloatCfg.emax - ↑prec
state_after: no goals

tactic: (rw [max_eq_right]; simp [sub_eq_add_neg])
state_before: C : FloatCfg
⊢ emin = max (emin + ↑(Nat.size 0) - ↑prec) emin
state_after: no goals

tactic: rw [max_eq_right]
state_before: C : FloatCfg
⊢ emin = max (emin + ↑(Nat.size 0) - ↑prec) emin
state_after: C : FloatCfg
⊢ emin + ↑(Nat.size 0) - ↑prec ≤ emin

tactic: simp [sub_eq_add_neg]
state_before: C : FloatCfg
⊢ emin + ↑(Nat.size 0) - ↑prec ≤ emin
state_after: no goals
Theorem: eventually_countable_forall
File: Mathlib/Order/Filter/CountableInter.lean

tactic: simpa only [Filter.Eventually, setOf_forall] using
  @countable_iInter_mem _ _ l _ _ fun i => { x | p x i }
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
l : Filter α
inst✝¹ : CountableInterFilter l
inst✝ : Countable ι
p : α → ι → Prop
⊢ (∀ᶠ (x : α) in l, ∀ (i : ι), p x i) ↔ ∀ (i : ι), ∀ᶠ (x : α) in l, p x i
state_after: no goals
Theorem: IsNilpotent.isUnit_add_one
File: Mathlib/RingTheory/Nilpotent/Basic.lean

tactic: rw [← IsUnit.neg_iff, neg_add']
state_before: R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
r : R
hnil : IsNilpotent r
⊢ IsUnit (r + 1)
state_after: R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
r : R
hnil : IsNilpotent r
⊢ IsUnit (-r - 1)

tactic: exact isUnit_sub_one hnil.neg
state_before: R : Type u_1
S : Type u_2
x y : R
inst✝ : Ring R
r : R
hnil : IsNilpotent r
⊢ IsUnit (-r - 1)
state_after: no goals
Theorem: PythagoreanTriple.symm
File: Mathlib/NumberTheory/PythagoreanTriples.lean

tactic: rwa [pythagoreanTriple_comm]
state_before: x y z : ℤ
h : PythagoreanTriple x y z
⊢ PythagoreanTriple y x z
state_after: no goals
Theorem: Hyperreal.IsSt.infinitesimal_sub
File: Mathlib/Data/Real/Hyperreal.lean

tactic: simpa only [sub_self] using hxr.sub (isSt_refl_real r)
state_before: x : ℝ*
r : ℝ
hxr : x.IsSt r
⊢ (x - ↑r).Infinitesimal
state_after: no goals
Theorem: convexHull_toCone_isLeast
File: Mathlib/Analysis/Convex/Cone/Basic.lean

tactic: convert (convex_convexHull 𝕜 s).toCone_isLeast using 1
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
⊢ IsLeast {t | s ⊆ ↑t} (Convex.toCone ((convexHull 𝕜) s) ⋯)
state_after: case h.e'_3
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
⊢ {t | s ⊆ ↑t} = {t | (convexHull 𝕜) s ⊆ ↑t}

tactic: ext t
state_before: case h.e'_3
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
⊢ {t | s ⊆ ↑t} = {t | (convexHull 𝕜) s ⊆ ↑t}
state_after: case h.e'_3.h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
t : ConvexCone 𝕜 E
⊢ t ∈ {t | s ⊆ ↑t} ↔ t ∈ {t | (convexHull 𝕜) s ⊆ ↑t}

tactic: exact ⟨fun h => convexHull_min h t.convex, (subset_convexHull 𝕜 s).trans⟩
state_before: case h.e'_3.h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
t : ConvexCone 𝕜 E
⊢ t ∈ {t | s ⊆ ↑t} ↔ t ∈ {t | (convexHull 𝕜) s ⊆ ↑t}
state_after: no goals
Theorem: Set.iInter_setOf
File: Mathlib/Data/Set/Lattice.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
P : ι → α → Prop
⊢ ⋂ i, {x | P i x} = {x | ∀ (i : ι), P i x}
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
P : ι → α → Prop
x✝ : α
⊢ x✝ ∈ ⋂ i, {x | P i x} ↔ x✝ ∈ {x | ∀ (i : ι), P i x}

tactic: exact mem_iInter
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
P : ι → α → Prop
x✝ : α
⊢ x✝ ∈ ⋂ i, {x | P i x} ↔ x✝ ∈ {x | ∀ (i : ι), P i x}
state_after: no goals
Theorem: CategoryTheory.Bicategory.triangle_assoc_comp_left_inv
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp [← cancel_mono ((ρ_ f).hom ▷ g)]
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ f ◁ (λ_ g).inv ≫ (α_ f (𝟙 b) g).inv = (ρ_ f).inv ▷ g
state_after: no goals
Theorem: CategoryTheory.MonoidalClosed.uncurry_pre
File: Mathlib/CategoryTheory/Closed/Monoidal.lean

tactic: simp [uncurry_eq]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : MonoidalCategory C
A B X✝ X' Y Y' Z : C
inst✝¹ : Closed A
inst✝ : Closed B
f : B ⟶ A
X : C
⊢ uncurry ((pre f).app X) = f ▷ (ihom A).obj X ≫ (ihom.ev A).app X
state_after: no goals
Theorem: CategoryTheory.ShortComplex.RightHomologyData.ofIsColimitCokernelCofork_g'
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

tactic: rw [← cancel_epi (ofIsColimitCokernelCofork S hg c hc).p, p_g', hg, comp_zero]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
A : C
hg : S.g = 0
c : CokernelCofork S.f
hc : IsColimit c
⊢ (ofIsColimitCokernelCofork S hg c hc).g' = 0
state_after: no goals
Theorem: Algebraic.cardinal_mk_le_max
File: Mathlib/Algebra/AlgebraicCard.lean

tactic: rw [← lift_id #_, ← lift_id #R]
state_before: R A : Type u
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : IsDomain A
inst✝¹ : Algebra R A
inst✝ : NoZeroSMulDivisors R A
⊢ #{ x // IsAlgebraic R x } ≤ max #R ℵ₀
state_after: R A : Type u
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : IsDomain A
inst✝¹ : Algebra R A
inst✝ : NoZeroSMulDivisors R A
⊢ lift.{u, u} #{ x // IsAlgebraic R x } ≤ max (lift.{u, u} #R) ℵ₀

tactic: exact cardinal_mk_lift_le_max R A
state_before: R A : Type u
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : IsDomain A
inst✝¹ : Algebra R A
inst✝ : NoZeroSMulDivisors R A
⊢ lift.{u, u} #{ x // IsAlgebraic R x } ≤ max (lift.{u, u} #R) ℵ₀
state_after: no goals
Theorem: OrthonormalBasis.coe_mk
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

tactic: classical rw [OrthonormalBasis.mk, _root_.Basis.coe_toOrthonormalBasis, Basis.coe_mk]
state_before: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝⁹ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type u_7
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
v : ι → E
hon : Orthonormal 𝕜 v
hsp : ⊤ ≤ span 𝕜 (range v)
⊢ ⇑(OrthonormalBasis.mk hon hsp) = v
state_after: no goals

tactic: rw [OrthonormalBasis.mk, _root_.Basis.coe_toOrthonormalBasis, Basis.coe_mk]
state_before: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝⁹ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type u_7
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
v : ι → E
hon : Orthonormal 𝕜 v
hsp : ⊤ ≤ span 𝕜 (range v)
⊢ ⇑(OrthonormalBasis.mk hon hsp) = v
state_after: no goals
Theorem: Set.preimage_const_mul_Ioc_of_neg
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simpa only [mul_comm] using preimage_mul_const_Ioc_of_neg a b h
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
h : c < 0
⊢ (fun x => c * x) ⁻¹' Ioc a b = Ico (b / c) (a / c)
state_after: no goals