1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Set.injective_piecewise_iff
File: Mathlib/Data/Set/Function.lean

tactic: rw [injective_iff_injOn_univ, ← union_compl_self s, injOn_union (@disjoint_compl_right _ _ s),
  (piecewise_eqOn s f g).injOn_iff, (piecewise_eqOn_compl s f g).injOn_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f✝ g✝ : (i : α) → δ i
inst✝ : (j : α) → Decidable (j ∈ s)
f g : α → β
⊢ Injective (s.piecewise f g) ↔ InjOn f s ∧ InjOn g sᶜ ∧ ∀ x ∈ s, ∀ y ∉ s, f x ≠ g y
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f✝ g✝ : (i : α) → δ i
inst✝ : (j : α) → Decidable (j ∈ s)
f g : α → β
⊢ (InjOn f s ∧ InjOn g sᶜ ∧ ∀ x ∈ s, ∀ y ∈ sᶜ, s.piecewise f g x ≠ s.piecewise f g y) ↔
    InjOn f s ∧ InjOn g sᶜ ∧ ∀ x ∈ s, ∀ y ∉ s, f x ≠ g y

tactic: refine and_congr Iff.rfl (and_congr Iff.rfl <| forall₄_congr fun x hx y hy => ?_)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f✝ g✝ : (i : α) → δ i
inst✝ : (j : α) → Decidable (j ∈ s)
f g : α → β
⊢ (InjOn f s ∧ InjOn g sᶜ ∧ ∀ x ∈ s, ∀ y ∈ sᶜ, s.piecewise f g x ≠ s.piecewise f g y) ↔
    InjOn f s ∧ InjOn g sᶜ ∧ ∀ x ∈ s, ∀ y ∉ s, f x ≠ g y
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f✝ g✝ : (i : α) → δ i
inst✝ : (j : α) → Decidable (j ∈ s)
f g : α → β
x : α
hx : x ∈ s
y : α
hy : y ∈ sᶜ
⊢ s.piecewise f g x ≠ s.piecewise f g y ↔ f x ≠ g y

tactic: rw [piecewise_eq_of_mem s f g hx, piecewise_eq_of_not_mem s f g hy]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f✝ g✝ : (i : α) → δ i
inst✝ : (j : α) → Decidable (j ∈ s)
f g : α → β
x : α
hx : x ∈ s
y : α
hy : y ∈ sᶜ
⊢ s.piecewise f g x ≠ s.piecewise f g y ↔ f x ≠ g y
state_after: no goals
Theorem: LaurentPolynomial.T_add
File: Mathlib/Algebra/Polynomial/Laurent.lean

tactic: simp [T, single_mul_single]
state_before: R : Type u_1
inst✝ : Semiring R
m n : ℤ
⊢ T (m + n) = T m * T n
state_after: no goals
Theorem: CategoryTheory.obj_zero_map_μ_app
File: Mathlib/CategoryTheory/Monoidal/End.lean

tactic: rw [← IsIso.inv_comp_eq, ← IsIso.comp_inv_eq]
state_before: C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m : M
X Y : C
f : X ⟶ (F.obj m).obj Y
⊢ (F.obj (𝟙_ M)).map f ≫ (F.μ m (𝟙_ M)).app Y = F.εIso.inv.app X ≫ f ≫ (F.map (ρ_ m).inv).app Y
state_after: C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m : M
X Y : C
f : X ⟶ (F.obj m).obj Y
⊢ (inv (F.εIso.inv.app X) ≫ (F.obj (𝟙_ M)).map f ≫ (F.μ m (𝟙_ M)).app Y) ≫ inv ((F.map (ρ_ m).inv).app Y) = f

tactic: simp
state_before: C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m : M
X Y : C
f : X ⟶ (F.obj m).obj Y
⊢ (inv (F.εIso.inv.app X) ≫ (F.obj (𝟙_ M)).map f ≫ (F.μ m (𝟙_ M)).app Y) ≫ inv ((F.map (ρ_ m).inv).app Y) = f
state_after: no goals
Theorem: MeasureTheory.lintegral_smul_measure
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp only [lintegral, iSup_subtype', SimpleFunc.lintegral_smul, ENNReal.mul_iSup, smul_eq_mul]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
c : ℝ≥0∞
f : α → ℝ≥0∞
⊢ ∫⁻ (a : α), f a ∂c • μ = c * ∫⁻ (a : α), f a ∂μ
state_after: no goals
Theorem: Function.Injective.smulCommClass
File: Mathlib/Algebra/Group/Action/Defs.lean

tactic: simp only [h₁, h₂, smul_comm c₁ c₂ (f x)]
state_before: M : Type u_1
N : Type u_2
G : Type u_3
A : Type u_4
B : Type u_5
α : Type u_6
β : Type u_7
γ : Type u_8
δ : Type u_9
inst✝⁴ : SMul M α
inst✝³ : SMul N α
inst✝² : SMul M β
inst✝¹ : SMul N β
inst✝ : SMulCommClass M N β
f : α → β
hf : Injective f
h₁ : ∀ (c : M) (x : α), f (c • x) = c • f x
h₂ : ∀ (c : N) (x : α), f (c • x) = c • f x
c₁ : M
c₂ : N
x : α
⊢ f (c₁ • c₂ • x) = f (c₂ • c₁ • x)
state_after: no goals
Theorem: Mathlib.Tactic.BicategoryCoherence.bicategoricalComp_refl
File: Mathlib/Tactic/CategoryTheory/BicategoryCoherence.lean

tactic: dsimp [bicategoricalComp]
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f g h : a ⟶ b
η : f ⟶ g
θ : g ⟶ h
⊢ η ⊗≫ θ = η ≫ θ
state_after: B : Type u
inst✝ : Bicategory B
a b c d e : B
f g h : a ⟶ b
η : f ⟶ g
θ : g ⟶ h
⊢ η ≫ 𝟙 g ≫ θ = η ≫ θ

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f g h : a ⟶ b
η : f ⟶ g
θ : g ⟶ h
⊢ η ≫ 𝟙 g ≫ θ = η ≫ θ
state_after: no goals
Theorem: EisensteinSeries.summand_bound_of_mem_verticalStrip
File: Mathlib/NumberTheory/ModularForms/EisensteinSeries/UniformConvergence.lean

tactic: refine (summand_bound z hk x).trans (mul_le_mul_of_nonneg_right ?_ (by positivity))
state_before: z : ℍ
k : ℝ
hk : 0 ≤ k
x : Fin 2 → ℤ
A B : ℝ
hB : 0 < B
hz : z ∈ verticalStrip A B
⊢ Complex.abs (↑(x 0) * ↑z + ↑(x 1)) ^ (-k) ≤ r ⟨{ re := A, im := B }, hB⟩ ^ (-k) * ‖x‖ ^ (-k)
state_after: z : ℍ
k : ℝ
hk : 0 ≤ k
x : Fin 2 → ℤ
A B : ℝ
hB : 0 < B
hz : z ∈ verticalStrip A B
⊢ r z ^ (-k) ≤ r ⟨{ re := A, im := B }, hB⟩ ^ (-k)

tactic: exact Real.rpow_le_rpow_of_nonpos (r_pos _) (r_lower_bound_on_verticalStrip z hB hz)
  (neg_nonpos.mpr hk)
state_before: z : ℍ
k : ℝ
hk : 0 ≤ k
x : Fin 2 → ℤ
A B : ℝ
hB : 0 < B
hz : z ∈ verticalStrip A B
⊢ r z ^ (-k) ≤ r ⟨{ re := A, im := B }, hB⟩ ^ (-k)
state_after: no goals

tactic: positivity
state_before: z : ℍ
k : ℝ
hk : 0 ≤ k
x : Fin 2 → ℤ
A B : ℝ
hB : 0 < B
hz : z ∈ verticalStrip A B
⊢ 0 ≤ ‖x‖ ^ (-k)
state_after: no goals
Theorem: Zsqrtd.sqLe_add
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: have xz := sqLe_add_mixed xy zw
state_before: d✝ : ℤ
c d x y z w : ℕ
xy : SqLe x c y d
zw : SqLe z c w d
⊢ SqLe (x + z) c (y + w) d
state_after: d✝ : ℤ
c d x y z w : ℕ
xy : SqLe x c y d
zw : SqLe z c w d
xz : c * (x * z) ≤ d * (y * w)
⊢ SqLe (x + z) c (y + w) d

tactic: simp? [SqLe, mul_assoc] at xy zw says simp only [SqLe, mul_assoc] at xy zw
state_before: d✝ : ℤ
c d x y z w : ℕ
xy : SqLe x c y d
zw : SqLe z c w d
xz : c * (x * z) ≤ d * (y * w)
⊢ SqLe (x + z) c (y + w) d
state_after: d✝ : ℤ
c d x y z w : ℕ
xz : c * (x * z) ≤ d * (y * w)
xy : c * (x * x) ≤ d * (y * y)
zw : c * (z * z) ≤ d * (w * w)
⊢ SqLe (x + z) c (y + w) d

tactic: simp [SqLe, mul_add, mul_comm, mul_left_comm, add_le_add, *]
state_before: d✝ : ℤ
c d x y z w : ℕ
xz : c * (x * z) ≤ d * (y * w)
xy : c * (x * x) ≤ d * (y * y)
zw : c * (z * z) ≤ d * (w * w)
⊢ SqLe (x + z) c (y + w) d
state_after: no goals

tactic: simp only [SqLe, mul_assoc] at xy zw
state_before: d✝ : ℤ
c d x y z w : ℕ
xy : SqLe x c y d
zw : SqLe z c w d
xz : c * (x * z) ≤ d * (y * w)
⊢ SqLe (x + z) c (y + w) d
state_after: d✝ : ℤ
c d x y z w : ℕ
xz : c * (x * z) ≤ d * (y * w)
xy : c * (x * x) ≤ d * (y * y)
zw : c * (z * z) ≤ d * (w * w)
⊢ SqLe (x + z) c (y + w) d
Theorem: Set.pi_univ_Ioc_update_union
File: Mathlib/Order/Interval/Set/Pi.lean

tactic: simp_rw [pi_univ_Ioc_update_left hm.1, pi_univ_Ioc_update_right hm.2, ← union_inter_distrib_right,
  ← setOf_or, le_or_lt, setOf_true, univ_inter]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → LinearOrder (α i)
x y : (i : ι) → α i
i₀ : ι
m : α i₀
hm : m ∈ Icc (x i₀) (y i₀)
⊢ ((univ.pi fun i => Ioc (x i) (update y i₀ m i)) ∪ univ.pi fun i => Ioc (update x i₀ m i) (y i)) =
    univ.pi fun i => Ioc (x i) (y i)
state_after: no goals
Theorem: ENNReal.exists_nnreal_pos_mul_lt
File: Mathlib/Data/ENNReal/Inv.lean

tactic: rcases exists_nat_pos_inv_mul_lt ha hb with ⟨n, npos : 0 < n, hn⟩
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ ⊤
hb : b ≠ 0
⊢ ∃ n > 0, ↑n * a < b
state_after: case intro.intro
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ ⊤
hb : b ≠ 0
n : ℕ
npos : 0 < n
hn : (↑n)⁻¹ * a < b
⊢ ∃ n > 0, ↑n * a < b

tactic: use (n : ℝ≥0)⁻¹
state_before: case intro.intro
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ ⊤
hb : b ≠ 0
n : ℕ
npos : 0 < n
hn : (↑n)⁻¹ * a < b
⊢ ∃ n > 0, ↑n * a < b
state_after: case h
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ ⊤
hb : b ≠ 0
n : ℕ
npos : 0 < n
hn : (↑n)⁻¹ * a < b
⊢ (↑n)⁻¹ > 0 ∧ ↑(↑n)⁻¹ * a < b

tactic: simp [*, npos.ne', zero_lt_one]
state_before: case h
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ ⊤
hb : b ≠ 0
n : ℕ
npos : 0 < n
hn : (↑n)⁻¹ * a < b
⊢ (↑n)⁻¹ > 0 ∧ ↑(↑n)⁻¹ * a < b
state_after: no goals
Theorem: LinearMap.toMatrix_reindexRange
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: simp_rw [LinearMap.toMatrix_apply, Basis.reindexRange_self, Basis.reindexRange_repr]
state_before: R : Type u_1
inst✝⁸ : CommSemiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝⁷ : Fintype n
inst✝⁶ : Finite m
inst✝⁵ : DecidableEq n
M₁ : Type u_5
M₂ : Type u_6
inst✝⁴ : AddCommMonoid M₁
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₁
inst✝¹ : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
inst✝ : DecidableEq M₁
f : M₁ →ₗ[R] M₂
k : m
i : n
⊢ (toMatrix v₁.reindexRange v₂.reindexRange) f ⟨v₂ k, ⋯⟩ ⟨v₁ i, ⋯⟩ = (toMatrix v₁ v₂) f k i
state_after: no goals
Theorem: Function.Antiperiodic.add_nsmul_eq
File: Mathlib/Algebra/Periodic.lean

tactic: rcases Nat.even_or_odd' n with ⟨k, rfl | rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddMonoid α
inst✝ : AddGroup β
h : Antiperiodic f c
n : ℕ
⊢ f (x + n • c) = (-1) ^ n • f x
state_after: case intro.inl
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddMonoid α
inst✝ : AddGroup β
h : Antiperiodic f c
k : ℕ
⊢ f (x + (2 * k) • c) = (-1) ^ (2 * k) • f x

case intro.inr
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddMonoid α
inst✝ : AddGroup β
h : Antiperiodic f c
k : ℕ
⊢ f (x + (2 * k + 1) • c) = (-1) ^ (2 * k + 1) • f x

tactic: rw [h.even_nsmul_periodic, pow_mul, (by norm_num : (-1) ^ 2 = 1), one_pow, one_zsmul]
state_before: case intro.inl
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddMonoid α
inst✝ : AddGroup β
h : Antiperiodic f c
k : ℕ
⊢ f (x + (2 * k) • c) = (-1) ^ (2 * k) • f x
state_after: no goals

tactic: norm_num
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddMonoid α
inst✝ : AddGroup β
h : Antiperiodic f c
k : ℕ
⊢ (-1) ^ 2 = 1
state_after: no goals

tactic: rw [h.odd_nsmul_antiperiodic, pow_add, pow_mul, (by norm_num : (-1) ^ 2 = 1), one_pow,
  pow_one, one_mul, neg_zsmul, one_zsmul]
state_before: case intro.inr
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddMonoid α
inst✝ : AddGroup β
h : Antiperiodic f c
k : ℕ
⊢ f (x + (2 * k + 1) • c) = (-1) ^ (2 * k + 1) • f x
state_after: no goals
Theorem: Cardinal.ofENat_le_one
File: Mathlib/SetTheory/Cardinal/ENat.lean

tactic: norm_cast
state_before: m : ℕ∞
⊢ ↑m ≤ 1 ↔ m ≤ 1
state_after: no goals
Theorem: ZNum.cast_sub
File: Mathlib/Data/Num/Lemmas.lean

tactic: simp [sub_eq_neg_add]
state_before: α : Type u_1
inst✝ : Ring α
m n : ZNum
⊢ ↑(m - n) = ↑m - ↑n
state_after: no goals
Theorem: SMulCommClass.of_mul_smul_one
File: Mathlib/Algebra/Group/Action/Defs.lean

tactic: rw [← H x z, smul_eq_mul, ← H, smul_eq_mul, mul_assoc]
state_before: M✝ : Type u_1
N✝ : Type u_2
G : Type u_3
A : Type u_4
B : Type u_5
α : Type u_6
β : Type u_7
γ : Type u_8
δ : Type u_9
M : Type u_10
N : Type u_11
inst✝¹ : Monoid N
inst✝ : SMul M N
H : ∀ (x : M) (y : N), y * x • 1 = x • y
x : M
y z : N
⊢ x • y • z = y • x • z
state_after: no goals
Theorem: egauge_le_of_smul_mem_of_ne
File: Mathlib/Analysis/Convex/EGauge.lean

tactic: rw [← nnnorm_inv]
state_before: 𝕜 : Type u_1
inst✝² : NormedDivisionRing 𝕜
α : Type u_2
E : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
c : 𝕜
s t : Set E
x y : E
r : ℝ≥0∞
h : c • x ∈ s
hc : c ≠ 0
⊢ egauge 𝕜 s x ≤ ↑‖c‖₊⁻¹
state_after: 𝕜 : Type u_1
inst✝² : NormedDivisionRing 𝕜
α : Type u_2
E : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
c : 𝕜
s t : Set E
x y : E
r : ℝ≥0∞
h : c • x ∈ s
hc : c ≠ 0
⊢ egauge 𝕜 s x ≤ ↑‖c⁻¹‖₊

tactic: exact egauge_le_of_mem_smul <| (mem_inv_smul_set_iff₀ hc _ _).2 h
state_before: 𝕜 : Type u_1
inst✝² : NormedDivisionRing 𝕜
α : Type u_2
E : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
c : 𝕜
s t : Set E
x y : E
r : ℝ≥0∞
h : c • x ∈ s
hc : c ≠ 0
⊢ egauge 𝕜 s x ≤ ↑‖c⁻¹‖₊
state_after: no goals
Theorem: intervalIntegrable_inv_iff
File: Mathlib/Analysis/SpecialFunctions/NonIntegrable.lean

tactic: simp only [← intervalIntegrable_sub_inv_iff, sub_zero]
state_before: E : Type u_1
F : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedAddCommGroup F
a b : ℝ
⊢ IntervalIntegrable (fun x => x⁻¹) volume a b ↔ a = b ∨ 0 ∉ [[a, b]]
state_after: no goals
Theorem: LucasLehmer.X.card_eq
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: dsimp [X]
state_before: q : ℕ+
⊢ Fintype.card (X q) = ↑q ^ 2
state_after: q : ℕ+
⊢ Fintype.card (ZMod ↑q × ZMod ↑q) = ↑q ^ 2

tactic: rw [Fintype.card_prod, ZMod.card q, sq]
state_before: q : ℕ+
⊢ Fintype.card (ZMod ↑q × ZMod ↑q) = ↑q ^ 2
state_after: no goals
Theorem: Multiset.cons_subset
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp [subset_iff, or_imp, forall_and]
state_before: α : Type u_1
β : Type v
γ : Type u_2
s✝ : Multiset α
a✝ a : α
s t : Multiset α
⊢ a ::ₘ s ⊆ t ↔ a ∈ t ∧ s ⊆ t
state_after: no goals
Theorem: Filter.not_le
File: Mathlib/Order/Filter/Basic.lean

tactic: simp_rw [le_def, not_forall, exists_prop]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s t : Set α
⊢ ¬f ≤ g ↔ ∃ s ∈ g, s ∉ f
state_after: no goals
Theorem: MeasureTheory.piPremeasure_pi_eval
File: Mathlib/MeasureTheory/Constructions/Pi.lean

tactic: simp only [eval, piPremeasure_pi']
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
s : Set ((i : ι) → α i)
⊢ piPremeasure m (univ.pi fun i => eval i '' s) = piPremeasure m s
state_after: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
s : Set ((i : ι) → α i)
⊢ ∏ i : ι, (m i) ((fun a => a i) '' s) = piPremeasure m s

tactic: rfl
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
s : Set ((i : ι) → α i)
⊢ ∏ i : ι, (m i) ((fun a => a i) '' s) = piPremeasure m s
state_after: no goals
Theorem: MeasureTheory.MeasurePreserving.lintegral_map_equiv
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [← MeasureTheory.lintegral_map_equiv f g, hg.map_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν✝ : Measure α
inst✝ : MeasurableSpace β
ν : Measure β
f : β → ℝ≥0∞
g : α ≃ᵐ β
hg : MeasurePreserving (⇑g) μ ν
⊢ ∫⁻ (a : β), f a ∂ν = ∫⁻ (a : α), f (g a) ∂μ
state_after: no goals
Theorem: LinearMap.IsAlt.isRefl
File: Mathlib/LinearAlgebra/SesquilinearForm.lean

tactic: intro x y h
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
Mₗ₁ : Type u_9
Mₗ₁' : Type u_10
Mₗ₂ : Type u_11
Mₗ₂' : Type u_12
K : Type u_13
K₁ : Type u_14
K₂ : Type u_15
V : Type u_16
V₁ : Type u_17
V₂ : Type u_18
n : Type u_19
inst✝⁵ : CommSemiring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : CommSemiring R₁
inst✝¹ : AddCommMonoid M₁
inst✝ : Module R₁ M₁
I₁ I₂ I : R₁ →+* R
B : M₁ →ₛₗ[I₁] M₁ →ₛₗ[I₂] M
H : B.IsAlt
⊢ B.IsRefl
state_after: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
Mₗ₁ : Type u_9
Mₗ₁' : Type u_10
Mₗ₂ : Type u_11
Mₗ₂' : Type u_12
K : Type u_13
K₁ : Type u_14
K₂ : Type u_15
V : Type u_16
V₁ : Type u_17
V₂ : Type u_18
n : Type u_19
inst✝⁵ : CommSemiring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : CommSemiring R₁
inst✝¹ : AddCommMonoid M₁
inst✝ : Module R₁ M₁
I₁ I₂ I : R₁ →+* R
B : M₁ →ₛₗ[I₁] M₁ →ₛₗ[I₂] M
H : B.IsAlt
x y : M₁
h : (B x) y = 0
⊢ (B y) x = 0

tactic: rw [← neg H, h, neg_zero]
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
Mₗ₁ : Type u_9
Mₗ₁' : Type u_10
Mₗ₂ : Type u_11
Mₗ₂' : Type u_12
K : Type u_13
K₁ : Type u_14
K₂ : Type u_15
V : Type u_16
V₁ : Type u_17
V₂ : Type u_18
n : Type u_19
inst✝⁵ : CommSemiring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : CommSemiring R₁
inst✝¹ : AddCommMonoid M₁
inst✝ : Module R₁ M₁
I₁ I₂ I : R₁ →+* R
B : M₁ →ₛₗ[I₁] M₁ →ₛₗ[I₂] M
H : B.IsAlt
x y : M₁
h : (B x) y = 0
⊢ (B y) x = 0
state_after: no goals
Theorem: MeasureTheory.measure_add_diff
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [← measure_union' disjoint_sdiff_right hs, union_diff_self]
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 α
hs : MeasurableSet s
t : Set α
⊢ μ s + μ (t \ s) = μ (s ∪ t)
state_after: no goals
Theorem: Sylow.stabilizer_eq_normalizer
File: Mathlib/GroupTheory/Sylow.lean

tactic: ext
state_before: p : ℕ
G : Type u_1
inst✝ : Group G
P : Sylow p G
⊢ stabilizer G P = (↑P).normalizer
state_after: case h
p : ℕ
G : Type u_1
inst✝ : Group G
P : Sylow p G
x✝ : G
⊢ x✝ ∈ stabilizer G P ↔ x✝ ∈ (↑P).normalizer

tactic: simp [Sylow.smul_eq_iff_mem_normalizer]
state_before: case h
p : ℕ
G : Type u_1
inst✝ : Group G
P : Sylow p G
x✝ : G
⊢ x✝ ∈ stabilizer G P ↔ x✝ ∈ (↑P).normalizer
state_after: no goals
Theorem: SeparationQuotient.tendsto_lift_nhds_mk
File: Mathlib/Topology/Inseparable.lean

tactic: simp only [← map_mk_nhds, tendsto_map'_iff, lift_comp_mk]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f✝ g : X → Y
t : Set (SeparationQuotient X)
f : X → α
hf : ∀ (x y : X), (x ~ᵢ y) → f x = f y
l : Filter α
⊢ Tendsto (lift f hf) (𝓝 (mk x)) l ↔ Tendsto f (𝓝 x) l
state_after: no goals
Theorem: Finmap.sigma_keys_lookup
File: Mathlib/Data/Finmap.lean

tactic: ext x
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s : Finmap β
⊢ (s.keys.sigma fun i => (lookup i s).toFinset) = { val := s.entries, nodup := ⋯ }
state_after: case a
α : Type u
β : α → Type v
inst✝ : DecidableEq α
s : Finmap β
x : (i : α) × β i
⊢ (x ∈ s.keys.sigma fun i => (lookup i s).toFinset) ↔ x ∈ { val := s.entries, nodup := ⋯ }

tactic: have : x ∈ s.entries → x.1 ∈ s.keys := Multiset.mem_map_of_mem _
state_before: case a
α : Type u
β : α → Type v
inst✝ : DecidableEq α
s : Finmap β
x : (i : α) × β i
⊢ (x ∈ s.keys.sigma fun i => (lookup i s).toFinset) ↔ x ∈ { val := s.entries, nodup := ⋯ }
state_after: case a
α : Type u
β : α → Type v
inst✝ : DecidableEq α
s : Finmap β
x : (i : α) × β i
this : x ∈ s.entries → x.fst ∈ s.keys
⊢ (x ∈ s.keys.sigma fun i => (lookup i s).toFinset) ↔ x ∈ { val := s.entries, nodup := ⋯ }

tactic: simpa [lookup_eq_some_iff]
state_before: case a
α : Type u
β : α → Type v
inst✝ : DecidableEq α
s : Finmap β
x : (i : α) × β i
this : x ∈ s.entries → x.fst ∈ s.keys
⊢ (x ∈ s.keys.sigma fun i => (lookup i s).toFinset) ↔ x ∈ { val := s.entries, nodup := ⋯ }
state_after: no goals
Theorem: norm_pow_le
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: simp only [Nat.zero_eq, pow_zero, norm_one, le_rfl]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝¹ : SeminormedRing α
inst✝ : NormOneClass α
a : α
n : ℕ
⊢ ‖a ^ Nat.zero‖ ≤ ‖a‖ ^ Nat.zero
state_after: no goals
Theorem: LucasLehmer.Int.coe_nat_two_pow_pred
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: decide
state_before: p : ℕ
⊢ 0 < 2
state_after: no goals
Theorem: LinearMap.ker_comp_of_ker_eq_bot
File: Mathlib/Algebra/Module/Submodule/Ker.lean

tactic: rw [ker_comp, hg, Submodule.comap_bot]
state_before: R : Type u_1
R₁ : 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
M₃ : Type u_9
V : Type u_10
V₂ : Type u_11
inst✝⁹ : Semiring R
inst✝⁸ : Semiring R₂
inst✝⁷ : Semiring R₃
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : AddCommMonoid M₃
inst✝³ : Module R M
inst✝² : Module R₂ M₂
inst✝¹ : Module R₃ M₃
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
f : M →ₛₗ[τ₁₂] M₂
g : M₂ →ₛₗ[τ₂₃] M₃
hg : ker g = ⊥
⊢ ker (g.comp f) = ker f
state_after: no goals
Theorem: UnitalShelf.act_self_act_eq
File: Mathlib/Algebra/Quandle.lean

tactic: have h : x ◃ (x ◃ y) = (x ◃ 1) ◃ (x ◃ y) := by rw [act_one]
state_before: S : Type u_1
inst✝ : UnitalShelf S
x y : S
⊢ x ◃ x ◃ y = x ◃ y
state_after: S : Type u_1
inst✝ : UnitalShelf S
x y : S
h : x ◃ x ◃ y = (x ◃ 1) ◃ x ◃ y
⊢ x ◃ x ◃ y = x ◃ y

tactic: rw [h, ← Shelf.self_distrib, one_act]
state_before: S : Type u_1
inst✝ : UnitalShelf S
x y : S
h : x ◃ x ◃ y = (x ◃ 1) ◃ x ◃ y
⊢ x ◃ x ◃ y = x ◃ y
state_after: no goals

tactic: rw [act_one]
state_before: S : Type u_1
inst✝ : UnitalShelf S
x y : S
⊢ x ◃ x ◃ y = (x ◃ 1) ◃ x ◃ y
state_after: no goals
Theorem: EReal.preimage_coe_Iio
File: Mathlib/Data/Real/EReal.lean

tactic: change (WithBot.some ∘ WithTop.some) ⁻¹' (Iio (WithBot.some (WithTop.some y))) = _
state_before: y : ℝ
⊢ Real.toEReal ⁻¹' Iio ↑y = Iio y
state_after: y : ℝ
⊢ WithBot.some ∘ WithTop.some ⁻¹' Iio ↑↑y = Iio y

tactic: refine preimage_comp.trans ?_
state_before: y : ℝ
⊢ WithBot.some ∘ WithTop.some ⁻¹' Iio ↑↑y = Iio y
state_after: y : ℝ
⊢ WithTop.some ⁻¹' (WithBot.some ⁻¹' Iio ↑↑y) = Iio y

tactic: simp only [WithBot.preimage_coe_Iio, WithTop.preimage_coe_Iio]
state_before: y : ℝ
⊢ WithTop.some ⁻¹' (WithBot.some ⁻¹' Iio ↑↑y) = Iio y
state_after: no goals
Theorem: StarSubalgebra.inf_toSubalgebra
File: Mathlib/Algebra/Star/Subalgebra.lean

tactic: ext
state_before: F : Type u_1
R : Type u_2
A : Type u_3
B : Type u_4
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
inst✝⁵ : StarRing A
inst✝⁴ : StarModule R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : StarRing B
inst✝ : StarModule R B
S T : StarSubalgebra R A
⊢ (S ⊓ T).toSubalgebra = S.toSubalgebra ⊓ T.toSubalgebra
state_after: case h
F : Type u_1
R : Type u_2
A : Type u_3
B : Type u_4
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
inst✝⁵ : StarRing A
inst✝⁴ : StarModule R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : StarRing B
inst✝ : StarModule R B
S T : StarSubalgebra R A
x✝ : A
⊢ x✝ ∈ (S ⊓ T).toSubalgebra ↔ x✝ ∈ S.toSubalgebra ⊓ T.toSubalgebra

tactic: simp
state_before: case h
F : Type u_1
R : Type u_2
A : Type u_3
B : Type u_4
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
inst✝⁵ : StarRing A
inst✝⁴ : StarModule R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : StarRing B
inst✝ : StarModule R B
S T : StarSubalgebra R A
x✝ : A
⊢ x✝ ∈ (S ⊓ T).toSubalgebra ↔ x✝ ∈ S.toSubalgebra ⊓ T.toSubalgebra
state_after: no goals
Theorem: CategoryTheory.Limits.equalizerSubobject_arrow
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp [equalizerSubobjectIso]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f g : X ⟶ Y
inst✝ : HasEqualizer f g
⊢ (equalizerSubobjectIso f g).hom ≫ equalizer.ι f g = (equalizerSubobject f g).arrow
state_after: no goals