tasksource/leandojo huggingface dataset:
Theorem: leftLim_eq_of_eq_bot
File: Mathlib/Topology/Algebra/Order/LeftRightLim.lean

tactic: rw [h'α.topology_eq_generate_intervals] at h
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : TopologicalSpace β
hα : TopologicalSpace α
h'α : OrderTopology α
f : α → β
a : α
h : 𝓝[Iio a] a = ⊥
⊢ leftLim f a = f a

tactic: simp [leftLim, ite_eq_left_iff, h]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : TopologicalSpace β
hα : TopologicalSpace α
h'α : OrderTopology α
f : α → β
a : α
h : 𝓝[Iio a] a = ⊥
⊢ leftLim f a = f a
Theorem: Multiset.noncommProd_map_aux
File: Mathlib/Data/Finset/NoncommProd.lean

tactic: simp only [Multiset.mem_map]
state_before: F : Type u_1
ι : Type ?u.85305
α : Type u_2
β : Type u_3
γ : Type ?u.85314
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid α
inst✝¹ : Monoid β
inst✝ : MonoidHomClass F α β
s : Multiset α
comm : Set.Pairwise {x | x ∈ s} Commute
f : F
⊢ Set.Pairwise {x | x ∈ map (↑f) s} Commute

tactic: rintro _ ⟨x, hx, rfl⟩ _ ⟨y, hy, rfl⟩ _
state_before: F : Type u_1
ι : Type ?u.85305
α : Type u_2
β : Type u_3
γ : Type ?u.85314
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid α
inst✝¹ : Monoid β
inst✝ : MonoidHomClass F α β
s : Multiset α
comm : Set.Pairwise {x | x ∈ s} Commute
f : F
⊢ Set.Pairwise {x | ∃ a, a ∈ s ∧ ↑f a = x} Commute

tactic: exact (comm.of_refl hx hy).map f
state_before: case intro.intro.intro.intro
F : Type u_1
ι : Type ?u.85305
α : Type u_2
β : Type u_3
γ : Type ?u.85314
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid α
inst✝¹ : Monoid β
inst✝ : MonoidHomClass F α β
s : Multiset α
comm : Set.Pairwise {x | x ∈ s} Commute
f : F
x : α
hx : x ∈ s
y : α
hy : y ∈ s
a✝ : ↑f x ≠ ↑f y
⊢ Commute (↑f x) (↑f y)
Theorem: Finset.exists_le_sum_fiber_of_sum_fiber_nonpos_of_nsmul_le_sum
File: Mathlib/Combinatorics/Pigeonhole.lean

tactic: simpa
state_before: α : Type u
β : Type v
M : Type w
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
w : α → M
b : M
n : ℕ
inst✝ : LinearOrderedCancelAddCommMonoid M
hf : ∀ (y : β), ¬y ∈ t → ∑ x in filter (fun x => f x = y) s, w x ≤ 0
ht : Finset.Nonempty t
hb : card t • b ≤ ∑ x in s, w x
⊢ ∑ _y in t, b ≤ ∑ x in s, w x
Theorem: Real.zero_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: simp [rpow_def, *]
state_before: x : ℝ
h : x ≠ 0
⊢ 0 ^ x = 0
Theorem: AlgHom.apply_mem_spectrum
File: Mathlib/Algebra/Algebra/Spectrum.lean

tactic: have h : ↑ₐ (φ a) - a ∈ RingHom.ker (φ : A →+* R) := by
  simp only [RingHom.mem_ker, map_sub, RingHom.coe_coe, AlgHomClass.commutes,
    Algebra.id.map_eq_id, RingHom.id_apply, sub_self]
state_before: F : Type u_2
R : Type u_1
A : Type u_3
B : Type ?u.1475208
inst✝⁶ : CommRing R
inst✝⁵ : Ring A
inst✝⁴ : Algebra R A
inst✝³ : Ring B
inst✝² : Algebra R B
inst✝¹ : AlgHomClass F R A R
inst✝ : Nontrivial R
φ : F
a : A
⊢ ↑φ a ∈ σ a

tactic: simp only [spectrum.mem_iff, ← mem_nonunits_iff,
  coe_subset_nonunits (RingHom.ker_ne_top (φ : A →+* R)) h]
state_before: F : Type u_2
R : Type u_1
A : Type u_3
B : Type ?u.1475208
inst✝⁶ : CommRing R
inst✝⁵ : Ring A
inst✝⁴ : Algebra R A
inst✝³ : Ring B
inst✝² : Algebra R B
inst✝¹ : AlgHomClass F R A R
inst✝ : Nontrivial R
φ : F
a : A
h : ↑↑ₐ (↑φ a) - a ∈ RingHom.ker ↑φ
⊢ ↑φ a ∈ σ a

tactic: simp only [RingHom.mem_ker, map_sub, RingHom.coe_coe, AlgHomClass.commutes,
  Algebra.id.map_eq_id, RingHom.id_apply, sub_self]
state_before: F : Type u_2
R : Type u_1
A : Type u_3
B : Type ?u.1475208
inst✝⁶ : CommRing R
inst✝⁵ : Ring A
inst✝⁴ : Algebra R A
inst✝³ : Ring B
inst✝² : Algebra R B
inst✝¹ : AlgHomClass F R A R
inst✝ : Nontrivial R
φ : F
a : A
⊢ ↑↑ₐ (↑φ a) - a ∈ RingHom.ker ↑φ
Theorem: Finsupp.erase_add
File: Mathlib/Data/Finsupp/Defs.lean

tactic: ext s
state_before: α : Type u_1
β : Type ?u.310309
γ : Type ?u.310312
ι : Type ?u.310315
M : Type u_2
M' : Type ?u.310321
N : Type ?u.310324
P : Type ?u.310327
G : Type ?u.310330
H : Type ?u.310333
R : Type ?u.310336
S : Type ?u.310339
inst✝ : AddZeroClass M
a : α
f f' : α →₀ M
⊢ erase a (f + f') = erase a f + erase a f'

tactic: by_cases hs : s = a
state_before: case h
α : Type u_1
β : Type ?u.310309
γ : Type ?u.310312
ι : Type ?u.310315
M : Type u_2
M' : Type ?u.310321
N : Type ?u.310324
P : Type ?u.310327
G : Type ?u.310330
H : Type ?u.310333
R : Type ?u.310336
S : Type ?u.310339
inst✝ : AddZeroClass M
a : α
f f' : α →₀ M
s : α
⊢ ↑(erase a (f + f')) s = ↑(erase a f + erase a f') s

tactic: rw [add_apply, erase_ne hs, erase_ne hs, erase_ne hs, add_apply]
state_before: case neg
α : Type u_1
β : Type ?u.310309
γ : Type ?u.310312
ι : Type ?u.310315
M : Type u_2
M' : Type ?u.310321
N : Type ?u.310324
P : Type ?u.310327
G : Type ?u.310330
H : Type ?u.310333
R : Type ?u.310336
S : Type ?u.310339
inst✝ : AddZeroClass M
a : α
f f' : α →₀ M
s : α
hs : ¬s = a
⊢ ↑(erase a (f + f')) s = ↑(erase a f + erase a f') s

tactic: rw [hs, add_apply, erase_same, erase_same, erase_same, add_zero]
state_before: case pos
α : Type u_1
β : Type ?u.310309
γ : Type ?u.310312
ι : Type ?u.310315
M : Type u_2
M' : Type ?u.310321
N : Type ?u.310324
P : Type ?u.310327
G : Type ?u.310330
H : Type ?u.310333
R : Type ?u.310336
S : Type ?u.310339
inst✝ : AddZeroClass M
a : α
f f' : α →₀ M
s : α
hs : s = a
⊢ ↑(erase a (f + f')) s = ↑(erase a f + erase a f') s
Theorem: isClosedMap_const
File: Mathlib/Topology/Separation.lean

tactic: simp_rw [const, h2s.image_const, isClosed_singleton]
state_before: α✝ : Type u
β✝ : Type v
inst✝³ : TopologicalSpace α✝
α : Type u_1
β : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : T1Space β
y : β
s : Set α
x✝ : IsClosed s
h2s : Set.Nonempty s
⊢ IsClosed (const α y '' s)
Theorem: List.map_concat
File: Mathlib/Data/List/Basic.lean

tactic: induction l <;> [rfl; simp only [*, concat_eq_append, cons_append, map, map_append]]
state_before: ι : Type ?u.132558
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β
a : α
l : List α
⊢ map f (concat l a) = concat (map f l) (f a)
Theorem: CategoryTheory.IsPullback.zero_left
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
P X✝ Y Z : C
fst : P ⟶ X✝
snd : P ⟶ Y
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ 0 ≫ 𝟙 X = 0 ≫ 0

tactic: simpa using
  @PullbackCone.equalizer_ext _ _ _ _ _ _ _ s _ 0 (𝟙 _)
    (by simpa using (PullbackCone.condition s).symm)
state_before: C : Type u₁
inst✝² : Category C
P X✝ Y Z : C
fst : P ⟶ X✝
snd : P ⟶ Y
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
s : Cone (cospan (𝟙 X) 0)
⊢ ∀ (j : WalkingCospan), (fun s => 0) s ≫ (PullbackCone.mk 0 0 (_ : 0 ≫ 𝟙 X = 0 ≫ 0)).π.app j = s.π.app j

tactic: simpa using (PullbackCone.condition s).symm
state_before: C : Type u₁
inst✝² : Category C
P X✝ Y Z : C
fst : P ⟶ X✝
snd : P ⟶ Y
f : X✝ ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
s : Cone (cospan (𝟙 X) 0)
⊢ 0 ≫ PullbackCone.fst s = 𝟙 s.pt ≫ PullbackCone.fst s
Theorem: StieltjesFunction.iInf_Ioi_eq
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

tactic: suffices Function.rightLim f x = ⨅ r : Ioi x, f r by rw [← this, f.rightLim_eq]
state_before: f✝ f : StieltjesFunction
x : ℝ
⊢ (⨅ (r : ↑(Ioi x)), ↑f ↑r) = ↑f x

tactic: rw [rightLim_eq_sInf f.mono, sInf_image']
state_before: f✝ f : StieltjesFunction
x : ℝ
⊢ rightLim (↑f) x = ⨅ (r : ↑(Ioi x)), ↑f ↑r

tactic: rw [← neBot_iff]
state_before: f✝ f : StieltjesFunction
x : ℝ
⊢ 𝓝[Ioi x] x ≠ ⊥

tactic: infer_instance
state_before: f✝ f : StieltjesFunction
x : ℝ
⊢ NeBot (𝓝[Ioi x] x)

tactic: rw [← this, f.rightLim_eq]
state_before: f✝ f : StieltjesFunction
x : ℝ
this : rightLim (↑f) x = ⨅ (r : ↑(Ioi x)), ↑f ↑r
⊢ (⨅ (r : ↑(Ioi x)), ↑f ↑r) = ↑f x
Theorem: ZMod.pow_card
File: Mathlib/FieldTheory/Finite/Basic.lean

tactic: have h := FiniteField.pow_card x
state_before: K : Type ?u.1001241
R : Type ?u.1001244
p : ℕ
inst✝ : Fact (Nat.Prime p)
x : ZMod p
⊢ x ^ p = x

tactic: rwa [ZMod.card p] at h
state_before: K : Type ?u.1001241
R : Type ?u.1001244
p : ℕ
inst✝ : Fact (Nat.Prime p)
x : ZMod p
h : x ^ Fintype.card (ZMod p) = x
⊢ x ^ p = x
Theorem: norm_cauchyPowerSeries_le
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

tactic: simp [cauchyPowerSeries, norm_smul, Real.pi_pos.le]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
R : ℝ
n : ℕ
⊢ ‖cauchyPowerSeries f c R n‖ = (2 * π)⁻¹ * ‖∮ (z : ℂ) in C(c, R), (z - c)⁻¹ ^ n • (z - c)⁻¹ • f z‖

tactic: simp [Real.pi_pos.le]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
R : ℝ
n : ℕ
⊢ 0 ≤ (2 * π)⁻¹

tactic: simp [norm_smul, mul_left_comm (|R|)]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
R : ℝ
n : ℕ
⊢ ((2 * π)⁻¹ *
      ∫ (θ : ℝ) in 0 ..2 * π,
        ‖deriv (circleMap c R) θ • (circleMap c R θ - c)⁻¹ ^ n • (circleMap c R θ - c)⁻¹ • f (circleMap c R θ)‖) =
    (2 * π)⁻¹ * ((Abs.abs R)⁻¹ ^ n * (Abs.abs R * ((Abs.abs R)⁻¹ * ∫ (x : ℝ) in 0 ..2 * π, ‖f (circleMap c R x)‖)))

tactic: rcases eq_or_ne R 0 with (rfl | hR)
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
R : ℝ
n : ℕ
⊢ (2 * π)⁻¹ * ((Abs.abs R)⁻¹ ^ n * (Abs.abs R * ((Abs.abs R)⁻¹ * ∫ (x : ℝ) in 0 ..2 * π, ‖f (circleMap c R x)‖))) ≤
    ((2 * π)⁻¹ * ∫ (θ : ℝ) in 0 ..2 * π, ‖f (circleMap c R θ)‖) * (Abs.abs R)⁻¹ ^ n

tactic: cases n <;> simp [-mul_inv_rev]
state_before: case inl
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
n : ℕ
⊢ (2 * π)⁻¹ * ((Abs.abs 0)⁻¹ ^ n * (Abs.abs 0 * ((Abs.abs 0)⁻¹ * ∫ (x : ℝ) in 0 ..2 * π, ‖f (circleMap c 0 x)‖))) ≤
    ((2 * π)⁻¹ * ∫ (θ : ℝ) in 0 ..2 * π, ‖f (circleMap c 0 θ)‖) * (Abs.abs 0)⁻¹ ^ n

tactic: rw [← mul_assoc, inv_mul_cancel (Real.two_pi_pos.ne.symm), one_mul]
state_before: case inl.zero
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
⊢ 0 ≤ (2 * π)⁻¹ * (2 * π * ‖f c‖)

tactic: apply norm_nonneg
state_before: case inl.zero
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
⊢ 0 ≤ ‖f c‖

tactic: rw [mul_inv_cancel_left₀, mul_assoc, mul_comm ((|R|)⁻¹ ^ n)]
state_before: case inr
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
R : ℝ
n : ℕ
hR : R ≠ 0
⊢ (2 * π)⁻¹ * ((Abs.abs R)⁻¹ ^ n * (Abs.abs R * ((Abs.abs R)⁻¹ * ∫ (x : ℝ) in 0 ..2 * π, ‖f (circleMap c R x)‖))) ≤
    ((2 * π)⁻¹ * ∫ (θ : ℝ) in 0 ..2 * π, ‖f (circleMap c R θ)‖) * (Abs.abs R)⁻¹ ^ n

tactic: rwa [Ne.def, _root_.abs_eq_zero]
state_before: case inr.h
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
R : ℝ
n : ℕ
hR : R ≠ 0
⊢ Abs.abs R ≠ 0
Theorem: mulSupport_comp_inv_smul
File: Mathlib/Data/Set/Pointwise/Support.lean

tactic: ext x
state_before: α : Type u_3
β : Type u_2
γ : Type u_1
inst✝² : Group α
inst✝¹ : MulAction α β
inst✝ : One γ
c : α
f : β → γ
⊢ (mulSupport fun x => f (c⁻¹ • x)) = c • mulSupport f

tactic: simp only [mem_smul_set_iff_inv_smul_mem, mem_mulSupport]
state_before: case h
α : Type u_3
β : Type u_2
γ : Type u_1
inst✝² : Group α
inst✝¹ : MulAction α β
inst✝ : One γ
c : α
f : β → γ
x : β
⊢ (x ∈ mulSupport fun x => f (c⁻¹ • x)) ↔ x ∈ c • mulSupport f
Theorem: LinearMap.toMatrix₂'_compl₂
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

tactic: rw [← LinearMap.comp_id B, ← LinearMap.compl₁₂]
state_before: R : Type u_1
R₁ : Type ?u.849082
R₂ : Type ?u.849085
M : Type ?u.849088
M₁ : Type ?u.849091
M₂ : Type ?u.849094
M₁' : Type ?u.849097
M₂' : Type ?u.849100
n : Type u_2
m : Type u_3
n' : Type ?u.849109
m' : Type u_4
ι : Type ?u.849115
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing R₁
inst✝⁸ : CommRing R₂
inst✝⁷ : Fintype n
inst✝⁶ : Fintype m
inst✝⁵ : DecidableEq n
inst✝⁴ : DecidableEq m
σ₁ : R₁ →+* R
σ₂ : R₂ →+* R
inst✝³ : Fintype n'
inst✝² : Fintype m'
inst✝¹ : DecidableEq n'
inst✝ : DecidableEq m'
B : (n → R) →ₗ[R] (m → R) →ₗ[R] R
f : (m' → R) →ₗ[R] m → R
⊢ ↑toMatrix₂' (compl₂ B f) = ↑toMatrix₂' B ⬝ ↑toMatrix' f

tactic: simp
state_before: R : Type u_1
R₁ : Type ?u.849082
R₂ : Type ?u.849085
M : Type ?u.849088
M₁ : Type ?u.849091
M₂ : Type ?u.849094
M₁' : Type ?u.849097
M₂' : Type ?u.849100
n : Type u_2
m : Type u_3
n' : Type ?u.849109
m' : Type u_4
ι : Type ?u.849115
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing R₁
inst✝⁸ : CommRing R₂
inst✝⁷ : Fintype n
inst✝⁶ : Fintype m
inst✝⁵ : DecidableEq n
inst✝⁴ : DecidableEq m
σ₁ : R₁ →+* R
σ₂ : R₂ →+* R
inst✝³ : Fintype n'
inst✝² : Fintype m'
inst✝¹ : DecidableEq n'
inst✝ : DecidableEq m'
B : (n → R) →ₗ[R] (m → R) →ₗ[R] R
f : (m' → R) →ₗ[R] m → R
⊢ ↑toMatrix₂' (compl₁₂ B id f) = ↑toMatrix₂' (comp B id) ⬝ ↑toMatrix' f
Theorem: MeasureTheory.LocallyIntegrableOn.mul_continuousOn
File: Mathlib/MeasureTheory/Function/LocallyIntegrable.lean

tactic: rw [MeasureTheory.locallyIntegrableOn_iff (Or.inr hs)] at hf⊢
state_before: X : Type u_1
Y : Type ?u.2499165
E : Type ?u.2499168
R : Type u_2
inst✝⁹ : MeasurableSpace X
inst✝⁸ : TopologicalSpace X
inst✝⁷ : MeasurableSpace Y
inst✝⁶ : TopologicalSpace Y
inst✝⁵ : NormedAddCommGroup E
f✝ : X → E
μ : Measure X
s✝ : Set X
inst✝⁴ : OpensMeasurableSpace X
A K : Set X
inst✝³ : LocallyCompactSpace X
inst✝² : T2Space X
inst✝¹ : NormedRing R
inst✝ : SecondCountableTopologyEither X R
f g : X → R
s : Set X
hf : LocallyIntegrableOn f s
hg : ContinuousOn g s
hs : IsOpen s
⊢ LocallyIntegrableOn (fun x => f x * g x) s

tactic: exact fun k hk_sub hk_c => (hf k hk_sub hk_c).mul_continuousOn (hg.mono hk_sub) hk_c
state_before: X : Type u_1
Y : Type ?u.2499165
E : Type ?u.2499168
R : Type u_2
inst✝⁹ : MeasurableSpace X
inst✝⁸ : TopologicalSpace X
inst✝⁷ : MeasurableSpace Y
inst✝⁶ : TopologicalSpace Y
inst✝⁵ : NormedAddCommGroup E
f✝ : X → E
μ : Measure X
s✝ : Set X
inst✝⁴ : OpensMeasurableSpace X
A K : Set X
inst✝³ : LocallyCompactSpace X
inst✝² : T2Space X
inst✝¹ : NormedRing R
inst✝ : SecondCountableTopologyEither X R
f g : X → R
s : Set X
hf : ∀ (k : Set X), k ⊆ s → IsCompact k → IntegrableOn f k
hg : ContinuousOn g s
hs : IsOpen s
⊢ ∀ (k : Set X), k ⊆ s → IsCompact k → IntegrableOn (fun x => f x * g x) k
Theorem: himp_inf_himp_inf_le
File: Mathlib/Order/Heyting/Basic.lean

tactic: simpa using @himp_le_himp_himp_himp
state_before: ι : Type ?u.31071
α : Type u_1
β : Type ?u.31077
inst✝ : GeneralizedHeytingAlgebra α
a b c d : α
⊢ (b ⇨ c) ⊓ (a ⇨ b) ⊓ a ≤ c
Theorem: MeasureTheory.SimpleFunc.setToSimpleFunc_neg
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: rw [map_setToSimpleFunc T h_add hf neg_zero, setToSimpleFunc, ← sum_neg_distrib]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.281574
G : Type ?u.281577
𝕜 : Type ?u.281580
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → E →L[ℝ] F
h_add : FinMeasAdditive μ T
f : α →ₛ E
hf : Integrable ↑f
⊢ setToSimpleFunc T (map Neg.neg f) = -setToSimpleFunc T f

tactic: exact Finset.sum_congr rfl fun x _ => ContinuousLinearMap.map_neg _ _
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.281574
G : Type ?u.281577
𝕜 : Type ?u.281580
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → E →L[ℝ] F
h_add : FinMeasAdditive μ T
f : α →ₛ E
hf : Integrable ↑f
⊢ ∑ x in SimpleFunc.range f, ↑(T (↑f ⁻¹' {x})) (-x) = ∑ x in SimpleFunc.range f, -↑(T (↑f ⁻¹' {x})) x
Theorem: List.length_filter_lt_length_iff_exists
File: Mathlib/Data/List/Count.lean

tactic: simpa [length_eq_countp_add_countp p l, countp_eq_length_filter] using
countp_pos (fun x => ¬p x) (l := l)
state_before: α : Type u_1
l✝ : List α
p q : α → Bool
l : List α
⊢ length (filter p l) < length l ↔ ∃ x, x ∈ l ∧ ¬p x = true
Theorem: Set.EqOn.cancel_right
File: Mathlib/Data/Set/Function.lean

tactic: intro b hb
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
ι : Sort ?u.48895
π : α → Type ?u.48900
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
hf : EqOn (g₁ ∘ f) (g₂ ∘ f) s
hf' : SurjOn f s t
⊢ EqOn g₁ g₂ t

tactic: obtain ⟨a, ha, rfl⟩ := hf' hb
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
ι : Sort ?u.48895
π : α → Type ?u.48900
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b✝ : β
hf : EqOn (g₁ ∘ f) (g₂ ∘ f) s
hf' : SurjOn f s t
b : β
hb : b ∈ t
⊢ g₁ b = g₂ b

tactic: exact hf ha
state_before: case intro.intro
α : Type u_1
β : Type u_3
γ : Type u_2
ι : Sort ?u.48895
π : α → Type ?u.48900
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a✝ : α
b : β
hf : EqOn (g₁ ∘ f) (g₂ ∘ f) s
hf' : SurjOn f s t
a : α
ha : a ∈ s
hb : f a ∈ t
⊢ g₁ (f a) = g₂ (f a)
Theorem: Asymptotics.superpolynomialDecay_mul_param_iff
File: Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean

tactic: simpa [mul_comm k] using superpolynomialDecay_param_mul_iff f hk
state_before: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : LinearOrderedField β
inst✝ : OrderTopology β
hk : Tendsto k l atTop
⊢ SuperpolynomialDecay l k (f * k) ↔ SuperpolynomialDecay l k f
Theorem: InitialSeg.eq_or_principal
File: Mathlib/Order/InitialSeg.lean

tactic: rw [← e]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.20498
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
inst✝ : IsWellOrder β s
f : r ≼i s
h : ¬∃ b, ∀ (x : β), s x b ↔ ∃ y, ↑f y = x
b x : β
x✝¹ : ∀ (y : β), s y x → Acc s y
IH : ∀ (y : β), s y x → ∃ a, ↑f a = y
hn : ∀ (x_1 : α), ¬↑f x_1 = x
y : β
x✝ : ∃ y_1, ↑f y_1 = y
a : α
e : ↑f a = y
⊢ s y x

tactic: exact
  (trichotomous _ _).resolve_right
    (not_or_of_not (hn a) fun hl => not_exists.2 hn (f.init hl))
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.20498
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
inst✝ : IsWellOrder β s
f : r ≼i s
h : ¬∃ b, ∀ (x : β), s x b ↔ ∃ y, ↑f y = x
b x : β
x✝¹ : ∀ (y : β), s y x → Acc s y
IH : ∀ (y : β), s y x → ∃ a, ↑f a = y
hn : ∀ (x_1 : α), ¬↑f x_1 = x
y : β
x✝ : ∃ y_1, ↑f y_1 = y
a : α
e : ↑f a = y
⊢ s (↑f a) x
Theorem: DihedralGroup.exponent
File: Mathlib/GroupTheory/SpecificGroups/Dihedral.lean

tactic: rcases eq_zero_or_neZero n with (rfl | hn)
state_before: n : ℕ
⊢ Monoid.exponent (DihedralGroup n) = lcm n 2

tactic: apply Nat.dvd_antisymm
state_before: case inr
n : ℕ
hn : NeZero n
⊢ Monoid.exponent (DihedralGroup n) = lcm n 2

tactic: exact Monoid.exponent_eq_zero_of_order_zero orderOf_r_one
state_before: case inl

⊢ Monoid.exponent (DihedralGroup 0) = lcm 0 2

tactic: apply Monoid.exponent_dvd_of_forall_pow_eq_one
state_before: case inr.a
n : ℕ
hn : NeZero n
⊢ Monoid.exponent (DihedralGroup n) ∣ lcm n 2

tactic: rintro (m | m)
state_before: case inr.a.hG
n : ℕ
hn : NeZero n
⊢ ∀ (g : DihedralGroup n), g ^ lcm n 2 = 1

tactic: rw [← orderOf_dvd_iff_pow_eq_one, orderOf_r]
state_before: case inr.a.hG.r
n : ℕ
hn : NeZero n
m : ZMod n
⊢ r m ^ lcm n 2 = 1

tactic: refine' Nat.dvd_trans ⟨gcd n m.val, _⟩ (dvd_lcm_left n 2)
state_before: case inr.a.hG.r
n : ℕ
hn : NeZero n
m : ZMod n
⊢ n / Nat.gcd n (ZMod.val m) ∣ lcm n 2

tactic: exact (Nat.div_mul_cancel (Nat.gcd_dvd_left n m.val)).symm
state_before: case inr.a.hG.r
n : ℕ
hn : NeZero n
m : ZMod n
⊢ n = n / Nat.gcd n (ZMod.val m) * gcd n (ZMod.val m)

tactic: rw [← orderOf_dvd_iff_pow_eq_one, orderOf_sr]
state_before: case inr.a.hG.sr
n : ℕ
hn : NeZero n
m : ZMod n
⊢ sr m ^ lcm n 2 = 1

tactic: exact dvd_lcm_right n 2
state_before: case inr.a.hG.sr
n : ℕ
hn : NeZero n
m : ZMod n
⊢ 2 ∣ lcm n 2

tactic: apply lcm_dvd
state_before: case inr.a
n : ℕ
hn : NeZero n
⊢ lcm n 2 ∣ Monoid.exponent (DihedralGroup n)

tactic: convert Monoid.order_dvd_exponent (r (1 : ZMod n))
state_before: case inr.a.hab
n : ℕ
hn : NeZero n
⊢ n ∣ Monoid.exponent (DihedralGroup n)

tactic: exact orderOf_r_one.symm
state_before: case h.e'_3
n : ℕ
hn : NeZero n
⊢ n = orderOf (r 1)

tactic: convert Monoid.order_dvd_exponent (sr (0 : ZMod n))
state_before: case inr.a.hcb
n : ℕ
hn : NeZero n
⊢ 2 ∣ Monoid.exponent (DihedralGroup n)

tactic: exact (orderOf_sr 0).symm
state_before: case h.e'_3
n : ℕ
hn : NeZero n
⊢ 2 = orderOf (sr 0)
Theorem: CompleteLattice.sup_continuous
File: Mathlib/Order/OmegaCompletePartialOrder.lean

tactic: rw [← sSup_pair]
state_before: α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
f g : α →o β
hf : Continuous f
hg : Continuous g
⊢ Continuous (f ⊔ g)

tactic: apply sSup_continuous
state_before: α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
f g : α →o β
hf : Continuous f
hg : Continuous g
⊢ Continuous (sSup {f, g})

tactic: rintro f (rfl | rfl | _) <;> assumption
state_before: case hs
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
f g : α →o β
hf : Continuous f
hg : Continuous g
⊢ ∀ (f_1 : α →o β), f_1 ∈ {f, g} → Continuous f_1
Theorem: Subalgebra.equivOfEq_rfl
File: Mathlib/Algebra/Algebra/Subalgebra/Basic.lean

tactic: ext
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S✝ S : Subalgebra R A
⊢ equivOfEq S S (_ : S = S) = AlgEquiv.refl

tactic: rfl
state_before: case h.a
R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S✝ S : Subalgebra R A
a✝ : { x // x ∈ S }
⊢ ↑(↑(equivOfEq S S (_ : S = S)) a✝) = ↑(↑AlgEquiv.refl a✝)
Theorem: mem_own_leftCoset
File: Mathlib/GroupTheory/Coset.lean

tactic: simpa
state_before: α : Type u_1
inst✝ : Monoid α
s : Submonoid α
a : α
this : a * 1 ∈ a *l ↑s
⊢ a ∈ a *l ↑s
Theorem: Int.add_ediv_of_dvd_left
File: Std/Data/Int/DivMod.lean

tactic: rw [Int.add_comm, Int.add_ediv_of_dvd_right H, Int.add_comm]
state_before: a b c : Int
H : c ∣ a
⊢ (a + b) / c = a / c + b / c
Theorem: Ordnode.dual_balance'
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: simp [balance', add_comm]
state_before: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
⊢ dual (balance' l x r) = balance' (dual r) x (dual l)

tactic: split_ifs with h h_1 h_2 <;>
simp [dual_node', dual_rotateL, dual_rotateR, add_comm]
state_before: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
⊢ dual
      (if size l + size r ≤ 1 then node' l x r
      else
        if delta * size l < size r then rotateL l x r
        else if delta * size r < size l then rotateR l x r else node' l x r) =
    if size l + size r ≤ 1 then node' (dual r) x (dual l)
    else
      if delta * size r < size l then rotateL (dual r) x (dual l)
      else if delta * size l < size r then rotateR (dual r) x (dual l) else node' (dual r) x (dual l)

tactic: cases delta_lt_false h_1 h_2
state_before: case inr.inl.inl
α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
h : ¬size l + size r ≤ 1
h_1 : delta * size l < size r
h_2 : delta * size r < size l
⊢ rotateR (dual r) x (dual l) = rotateL (dual r) x (dual l)
Theorem: toIocMod_add_toIcoMod_zero
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [_root_.add_comm, toIcoMod_add_toIocMod_zero]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocMod hp 0 (a - b) + toIcoMod hp 0 (b - a) = p
Theorem: List.disjoint_append_left
File: Std/Data/List/Lemmas.lean

tactic: simp [Disjoint, or_imp, forall_and]
state_before: α✝ : Type u_1
l₁ l₂ l : List α✝
⊢ Disjoint (l₁ ++ l₂) l ↔ Disjoint l₁ l ∧ Disjoint l₂ l
Theorem: Irrational.int_sub
File: Mathlib/Data/Real/Irrational.lean

tactic: simpa only [Rat.cast_coe_int] using h.rat_sub m
state_before: q : ℚ
x y : ℝ
h : Irrational x
m : ℤ
⊢ Irrational (↑m - x)