1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Seminorm.continuous_of_le
File: Mathlib/Analysis/Seminorm.lean

tactic: refine Seminorm.continuous_of_forall (fun r hr ↦ Filter.mem_of_superset
  (IsOpen.mem_nhds ?_ <| q.mem_ball_self hr) (ball_antitone hpq))
state_before: R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : SeminormedRing 𝕝
inst✝⁴ : AddCommGroup E
inst✝³ : Module 𝕜 E
inst✝² : Module 𝕝 E
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalAddGroup E
p q : Seminorm 𝕝 E
hq : Continuous ⇑q
hpq : p ≤ q
⊢ Continuous ⇑p
state_after: R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : SeminormedRing 𝕝
inst✝⁴ : AddCommGroup E
inst✝³ : Module 𝕜 E
inst✝² : Module 𝕝 E
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalAddGroup E
p q : Seminorm 𝕝 E
hq : Continuous ⇑q
hpq : p ≤ q
r : ℝ
hr : r > 0
⊢ IsOpen (q.ball 0 r)

tactic: rw [ball_zero_eq]
state_before: R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : SeminormedRing 𝕝
inst✝⁴ : AddCommGroup E
inst✝³ : Module 𝕜 E
inst✝² : Module 𝕝 E
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalAddGroup E
p q : Seminorm 𝕝 E
hq : Continuous ⇑q
hpq : p ≤ q
r : ℝ
hr : r > 0
⊢ IsOpen (q.ball 0 r)
state_after: R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : SeminormedRing 𝕝
inst✝⁴ : AddCommGroup E
inst✝³ : Module 𝕜 E
inst✝² : Module 𝕝 E
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalAddGroup E
p q : Seminorm 𝕝 E
hq : Continuous ⇑q
hpq : p ≤ q
r : ℝ
hr : r > 0
⊢ IsOpen {y | q y < r}

tactic: exact isOpen_lt hq continuous_const
state_before: R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : SeminormedRing 𝕝
inst✝⁴ : AddCommGroup E
inst✝³ : Module 𝕜 E
inst✝² : Module 𝕝 E
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalAddGroup E
p q : Seminorm 𝕝 E
hq : Continuous ⇑q
hpq : p ≤ q
r : ℝ
hr : r > 0
⊢ IsOpen {y | q y < r}
state_after: no goals
Theorem: Bundle.Trivial.inducing_toProd
File: Mathlib/Topology/FiberBundle/Constructions.lean

tactic: simp only [instTopologicalSpaceProd, induced_inf, induced_compose]
state_before: B : Type u_1
F : Type u_2
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
⊢ topologicalSpace B F = induced (⇑(TotalSpace.toProd B F)) instTopologicalSpaceProd
state_after: B : Type u_1
F : Type u_2
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
⊢ topologicalSpace B F =
    induced (Prod.fst ∘ ⇑(TotalSpace.toProd B F)) inst✝¹ ⊓ induced (Prod.snd ∘ ⇑(TotalSpace.toProd B F)) inst✝

tactic: rfl
state_before: B : Type u_1
F : Type u_2
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
⊢ topologicalSpace B F =
    induced (Prod.fst ∘ ⇑(TotalSpace.toProd B F)) inst✝¹ ⊓ induced (Prod.snd ∘ ⇑(TotalSpace.toProd B F)) inst✝
state_after: no goals
Theorem: Nat.choose_one_right
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: induction n <;> simp [*, choose, Nat.add_comm]
state_before: n : ℕ
⊢ n.choose 1 = n
state_after: no goals
Theorem: CliffordAlgebra.even.lift.aux_ι
File: Mathlib/LinearAlgebra/CliffordAlgebra/Even.lean

tactic: rw [foldr_ι, foldr_ι]
state_before: R : Type uR
M : Type uM
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
A : Type uA
B : Type uB
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : EvenHom Q A
m₁ m₂ : M
⊢ (((foldr Q (CliffordAlgebra.even.lift.fFold f) ⋯)
          (((foldr Q (CliffordAlgebra.even.lift.fFold f) ⋯) (1, 0)) ((CliffordAlgebra.ι Q) m₂)))
        ((CliffordAlgebra.ι Q) m₁)).1 =
    (f.bilin m₁) m₂
state_after: R : Type uR
M : Type uM
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
A : Type uA
B : Type uB
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : EvenHom Q A
m₁ m₂ : M
⊢ (((CliffordAlgebra.even.lift.fFold f) m₁) (((CliffordAlgebra.even.lift.fFold f) m₂) (1, 0))).1 = (f.bilin m₁) m₂

tactic: exact mul_one _
state_before: R : Type uR
M : Type uM
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
A : Type uA
B : Type uB
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : EvenHom Q A
m₁ m₂ : M
⊢ (((CliffordAlgebra.even.lift.fFold f) m₁) (((CliffordAlgebra.even.lift.fFold f) m₂) (1, 0))).1 = (f.bilin m₁) m₂
state_after: no goals
Theorem: StrongConvexOn.mono
File: Mathlib/Analysis/Convex/Strong.lean

tactic: gcongr
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s✝ : Set E
a b m✝ : ℝ
x y : E
f✝ g : E → ℝ
s : Set E
f : E → ℝ
m n : ℝ
hmn : m ≤ n
hf : StrongConvexOn s n f
r : ℝ
⊢ m / 2 * r ^ 2 ≤ n / 2 * r ^ 2
state_after: no goals
Theorem: List.Nodup.mem_diff_iff
File: Mathlib/Data/List/Nodup.lean

tactic: rw [hl₁.diff_eq_filter, mem_filter, decide_eq_true_iff]
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
hl₁ : l₁.Nodup
⊢ a ∈ l₁.diff l₂ ↔ a ∈ l₁ ∧ a ∉ l₂
state_after: no goals
Theorem: WithLp.unitization_norm_def
File: Mathlib/Analysis/NormedSpace/UnitizationL1.lean

tactic: simp
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝⁴ : NormedField 𝕜
inst✝³ : NonUnitalNormedRing A
inst✝² : NormedSpace 𝕜 A
inst✝¹ : IsScalarTower 𝕜 A A
inst✝ : SMulCommClass 𝕜 A A
x : WithLp 1 (Unitization 𝕜 A)
⊢ 0 < ENNReal.toReal 1
state_after: no goals

tactic: simp
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝⁴ : NormedField 𝕜
inst✝³ : NonUnitalNormedRing A
inst✝² : NormedSpace 𝕜 A
inst✝¹ : IsScalarTower 𝕜 A A
inst✝ : SMulCommClass 𝕜 A A
x : WithLp 1 (Unitization 𝕜 A)
⊢ (‖((WithLp.equiv 1 (Unitization 𝕜 A)) x).fst‖ ^ ENNReal.toReal 1 +
        ‖((WithLp.equiv 1 (Unitization 𝕜 A)) x).snd‖ ^ ENNReal.toReal 1) ^
      (1 / ENNReal.toReal 1) =
    ‖((WithLp.equiv 1 (Unitization 𝕜 A)) x).fst‖ + ‖((WithLp.equiv 1 (Unitization 𝕜 A)) x).snd‖
state_after: no goals
Theorem: AkraBazziRecurrence.strictMonoOn_one_sub_smoothingFn
File: Mathlib/Computability/AkraBazzi/AkraBazzi.lean

tactic: simp_rw [sub_eq_add_neg]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ StrictMonoOn (fun x => 1 - ε x) (Set.Ioi 1)
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ StrictMonoOn (fun x => 1 + -ε x) (Set.Ioi 1)

tactic: exact StrictMonoOn.const_add (StrictAntiOn.neg <| strictAntiOn_smoothingFn) 1
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ StrictMonoOn (fun x => 1 + -ε x) (Set.Ioi 1)
state_after: no goals
Theorem: Metric.uniformEmbedding_bot_of_pairwise_le_dist
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: infer_instance
state_before: α : Type u
β✝ : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
γ : Type w
inst✝ : MetricSpace γ
x : γ
s : Set γ
β : Type u_3
ε : ℝ
hε : 0 < ε
f : β → α
hf : Pairwise fun x y => ε ≤ dist (f x) (f y)
⊢ UniformSpace α
state_after: no goals

tactic: simpa using hf
state_before: α : Type u
β✝ : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
γ : Type w
inst✝ : MetricSpace γ
x : γ
s : Set γ
β : Type u_3
ε : ℝ
hε : 0 < ε
f : β → α
hf : Pairwise fun x y => ε ≤ dist (f x) (f y)
⊢ Pairwise fun x y => (f x, f y) ∉ {p | dist p.1 p.2 < ε}
state_after: no goals
Theorem: OrderMonoidHom.toOrderHom_injective
File: Mathlib/Algebra/Order/Hom/Monoid.lean

tactic: convert DFunLike.ext_iff.1 h using 0
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁷ : Preorder α
inst✝⁶ : Preorder β
inst✝⁵ : Preorder γ
inst✝⁴ : Preorder δ
inst✝³ : MulOneClass α
inst✝² : MulOneClass β
inst✝¹ : MulOneClass γ
inst✝ : MulOneClass δ
f✝ g✝ f g : α →*o β
h : f.toOrderHom = g.toOrderHom
⊢ ∀ (a : α), f a = g a
state_after: no goals
Theorem: CategoryTheory.GrothendieckTopology.over_map_coverPreserving
File: Mathlib/CategoryTheory/Sites/Over.lean

tactic: obtain ⟨S, rfl⟩ := (Sieve.overEquiv U).symm.surjective S
state_before: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
X Y : C
f : X ⟶ Y
U : Over X
S : Sieve U
hS : S ∈ (J.over X).sieves U
⊢ Sieve.functorPushforward (Over.map f) S ∈ (J.over Y).sieves ((Over.map f).obj U)
state_after: case intro
C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
X Y : C
f : X ⟶ Y
U : Over X
S : Sieve U.left
hS : (Sieve.overEquiv U).symm S ∈ (J.over X).sieves U
⊢ Sieve.functorPushforward (Over.map f) ((Sieve.overEquiv U).symm S) ∈ (J.over Y).sieves ((Over.map f).obj U)

tactic: rw [Sieve.functorPushforward_over_map]
state_before: case intro
C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
X Y : C
f : X ⟶ Y
U : Over X
S : Sieve U.left
hS : (Sieve.overEquiv U).symm S ∈ (J.over X).sieves U
⊢ Sieve.functorPushforward (Over.map f) ((Sieve.overEquiv U).symm S) ∈ (J.over Y).sieves ((Over.map f).obj U)
state_after: case intro
C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
X Y : C
f : X ⟶ Y
U : Over X
S : Sieve U.left
hS : (Sieve.overEquiv U).symm S ∈ (J.over X).sieves U
⊢ (Sieve.overEquiv ((Over.map f).obj U)).symm S ∈ (J.over Y).sieves ((Over.map f).obj U)

tactic: apply overEquiv_symm_mem_over
state_before: case intro
C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
X Y : C
f : X ⟶ Y
U : Over X
S : Sieve U.left
hS : (Sieve.overEquiv U).symm S ∈ (J.over X).sieves U
⊢ (Sieve.overEquiv ((Over.map f).obj U)).symm S ∈ (J.over Y).sieves ((Over.map f).obj U)
state_after: case intro.hS
C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
X Y : C
f : X ⟶ Y
U : Over X
S : Sieve U.left
hS : (Sieve.overEquiv U).symm S ∈ (J.over X).sieves U
⊢ S ∈ J.sieves ((Over.map f).obj U).left

tactic: simpa [mem_over_iff] using hS
state_before: case intro.hS
C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
X Y : C
f : X ⟶ Y
U : Over X
S : Sieve U.left
hS : (Sieve.overEquiv U).symm S ∈ (J.over X).sieves U
⊢ S ∈ J.sieves ((Over.map f).obj U).left
state_after: no goals
Theorem: Sum.id_traverse
File: Mathlib/Control/Traversable/Instances.lean

tactic: cases x <;> rfl
state_before: σ✝ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
σ α : Type u_1
x : σ ⊕ α
⊢ Sum.traverse pure x = x
state_after: no goals
Theorem: Batteries.AssocList.contains_eq
File: .lake/packages/batteries/Batteries/Data/AssocList.lean

tactic: induction l <;> simp [*, contains]
state_before: α : Type u_1
β : Type u_2
inst✝ : BEq α
a : α
l : AssocList α β
⊢ contains a l = l.toList.any fun x => x.fst == a
state_after: no goals
Theorem: Equiv.Perm.decomposeOption_symm_sign
File: Mathlib/GroupTheory/Perm/Option.lean

tactic: simp
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
e : Perm α
⊢ sign (decomposeOption.symm (none, e)) = sign e
state_after: no goals
Theorem: Polynomial.coeff_zero_reverse
File: Mathlib/Algebra/Polynomial/Reverse.lean

tactic: rw [coeff_reverse, revAt_le (zero_le f.natDegree), tsub_zero, leadingCoeff]
state_before: R : Type u_1
inst✝ : Semiring R
f✝ f : R[X]
⊢ f.reverse.coeff 0 = f.leadingCoeff
state_after: no goals
Theorem: LucasLehmer.mersenne_coe_X
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: ext <;> simp [mersenne, q, ZMod.natCast_zmod_eq_zero_iff_dvd, -pow_pos]
state_before: p : ℕ
⊢ ↑(mersenne p) = 0
state_after: case h₁
p : ℕ
⊢ (2 ^ p - 1).minFac ∣ 2 ^ p - 1

tactic: apply Nat.minFac_dvd
state_before: case h₁
p : ℕ
⊢ (2 ^ p - 1).minFac ∣ 2 ^ p - 1
state_after: no goals
Theorem: MeasureTheory.Measure.empty_of_count_eq_zero'
File: Mathlib/MeasureTheory/Measure/Count.lean

tactic: have hs : s.Finite := by
  rw [← count_apply_lt_top' s_mble, hsc]
  exact WithTop.zero_lt_top
state_before: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s : Set α
s_mble : MeasurableSet s
hsc : count s = 0
⊢ s = ∅
state_after: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s : Set α
s_mble : MeasurableSet s
hsc : count s = 0
hs : s.Finite
⊢ s = ∅

tactic: simpa [count_apply_finite' hs s_mble] using hsc
state_before: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s : Set α
s_mble : MeasurableSet s
hsc : count s = 0
hs : s.Finite
⊢ s = ∅
state_after: no goals

tactic: rw [← count_apply_lt_top' s_mble, hsc]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s : Set α
s_mble : MeasurableSet s
hsc : count s = 0
⊢ s.Finite
state_after: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s : Set α
s_mble : MeasurableSet s
hsc : count s = 0
⊢ 0 < ⊤

tactic: exact WithTop.zero_lt_top
state_before: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s : Set α
s_mble : MeasurableSet s
hsc : count s = 0
⊢ 0 < ⊤
state_after: no goals
Theorem: Filter.tendsto_mul_const_atBot_of_neg
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simpa only [mul_comm] using tendsto_const_mul_atBot_of_neg hr
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrderedField α
l : Filter β
f : β → α
r : α
hr : r < 0
⊢ Tendsto (fun x => f x * r) l atBot ↔ Tendsto f l atTop
state_after: no goals
Theorem: MeasureTheory.snorm_const
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

tactic: by_cases h_top : p = ∞
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
c : F
h0 : p ≠ 0
hμ : μ ≠ 0
⊢ snorm (fun x => c) p μ = ↑‖c‖₊ * μ Set.univ ^ (1 / p.toReal)
state_after: case pos
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
c : F
h0 : p ≠ 0
hμ : μ ≠ 0
h_top : p = ⊤
⊢ snorm (fun x => c) p μ = ↑‖c‖₊ * μ Set.univ ^ (1 / p.toReal)

case neg
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
c : F
h0 : p ≠ 0
hμ : μ ≠ 0
h_top : ¬p = ⊤
⊢ snorm (fun x => c) p μ = ↑‖c‖₊ * μ Set.univ ^ (1 / p.toReal)

tactic: simp [snorm_eq_snorm' h0 h_top, snorm'_const, ENNReal.toReal_pos h0 h_top]
state_before: case neg
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
c : F
h0 : p ≠ 0
hμ : μ ≠ 0
h_top : ¬p = ⊤
⊢ snorm (fun x => c) p μ = ↑‖c‖₊ * μ Set.univ ^ (1 / p.toReal)
state_after: no goals

tactic: simp [h_top, snormEssSup_const c hμ]
state_before: case pos
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
c : F
h0 : p ≠ 0
hμ : μ ≠ 0
h_top : p = ⊤
⊢ snorm (fun x => c) p μ = ↑‖c‖₊ * μ Set.univ ^ (1 / p.toReal)
state_after: no goals
Theorem: RingCon.sInf_toSetoid
File: Mathlib/RingTheory/Congruence/Basic.lean

tactic: rw [← hr]
state_before: α : Type u_1
R : Type u_2
inst✝¹ : Add R
inst✝ : Mul R
S : Set (RingCon R)
x y : R
h : (sInf S).Rel x y
r : Setoid R
x✝ : r ∈ (fun x => x.toSetoid) '' S
c : RingCon R
hS : c ∈ S
hr : (fun x => x.toSetoid) c = r
⊢ r.Rel x y
state_after: α : Type u_1
R : Type u_2
inst✝¹ : Add R
inst✝ : Mul R
S : Set (RingCon R)
x y : R
h : (sInf S).Rel x y
r : Setoid R
x✝ : r ∈ (fun x => x.toSetoid) '' S
c : RingCon R
hS : c ∈ S
hr : (fun x => x.toSetoid) c = r
⊢ ((fun x => x.toSetoid) c).Rel x y

tactic: exact h c hS
state_before: α : Type u_1
R : Type u_2
inst✝¹ : Add R
inst✝ : Mul R
S : Set (RingCon R)
x y : R
h : (sInf S).Rel x y
r : Setoid R
x✝ : r ∈ (fun x => x.toSetoid) '' S
c : RingCon R
hS : c ∈ S
hr : (fun x => x.toSetoid) c = r
⊢ ((fun x => x.toSetoid) c).Rel x y
state_after: no goals
Theorem: Filter.smallSets_bot
File: Mathlib/Order/Filter/SmallSets.lean

tactic: rw [smallSets, lift'_bot, powerset_empty, principal_singleton]
state_before: α : Type u_1
β : Type u_2
ι : Sort u_3
l l' la : Filter α
lb : Filter β
⊢ ⊥.smallSets = pure ∅
state_after: α : Type u_1
β : Type u_2
ι : Sort u_3
l l' la : Filter α
lb : Filter β
⊢ Monotone powerset

tactic: exact monotone_powerset
state_before: α : Type u_1
β : Type u_2
ι : Sort u_3
l l' la : Filter α
lb : Filter β
⊢ Monotone powerset
state_after: no goals
Theorem: Set.toFinset_congr
File: Mathlib/Data/Fintype/Basic.lean

tactic: subst h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ t✝ s t : Set α
inst✝¹ : Fintype ↑s
inst✝ : Fintype ↑t
h : s = t
⊢ s.toFinset = t.toFinset
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ t s : Set α
inst✝¹ inst✝ : Fintype ↑s
⊢ s.toFinset = s.toFinset

tactic: congr
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ t s : Set α
inst✝¹ inst✝ : Fintype ↑s
⊢ s.toFinset = s.toFinset
state_after: case h.e_3.h
α : Type u_1
β : Type u_2
γ : Type u_3
s✝ t s : Set α
inst✝¹ inst✝ : Fintype ↑s
⊢ inst✝¹ = inst✝

tactic: exact Subsingleton.elim _ _
state_before: case h.e_3.h
α : Type u_1
β : Type u_2
γ : Type u_3
s✝ t s : Set α
inst✝¹ inst✝ : Fintype ↑s
⊢ inst✝¹ = inst✝
state_after: no goals
Theorem: Finset.pred_card_le_card_erase
File: Mathlib/Data/Finset/Card.lean

tactic: by_cases h : a ∈ s
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t : Finset α
a b : α
inst✝ : DecidableEq α
⊢ s.card - 1 ≤ (s.erase a).card
state_after: case pos
α : Type u_1
β : Type u_2
R : Type u_3
s t : Finset α
a b : α
inst✝ : DecidableEq α
h : a ∈ s
⊢ s.card - 1 ≤ (s.erase a).card

case neg
α : Type u_1
β : Type u_2
R : Type u_3
s t : Finset α
a b : α
inst✝ : DecidableEq α
h : a ∉ s
⊢ s.card - 1 ≤ (s.erase a).card

tactic: exact (card_erase_of_mem h).ge
state_before: case pos
α : Type u_1
β : Type u_2
R : Type u_3
s t : Finset α
a b : α
inst✝ : DecidableEq α
h : a ∈ s
⊢ s.card - 1 ≤ (s.erase a).card
state_after: no goals

tactic: rw [erase_eq_of_not_mem h]
state_before: case neg
α : Type u_1
β : Type u_2
R : Type u_3
s t : Finset α
a b : α
inst✝ : DecidableEq α
h : a ∉ s
⊢ s.card - 1 ≤ (s.erase a).card
state_after: case neg
α : Type u_1
β : Type u_2
R : Type u_3
s t : Finset α
a b : α
inst✝ : DecidableEq α
h : a ∉ s
⊢ s.card - 1 ≤ s.card

tactic: exact Nat.sub_le _ _
state_before: case neg
α : Type u_1
β : Type u_2
R : Type u_3
s t : Finset α
a b : α
inst✝ : DecidableEq α
h : a ∉ s
⊢ s.card - 1 ≤ s.card
state_after: no goals
Theorem: Equiv.some_removeNone_iff
File: Mathlib/Logic/Equiv/Option.lean

tactic: cases' h : e (some x) with a
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
e : Option α ≃ Option β
x : α
⊢ some (e.removeNone x) = e none ↔ e.symm none = some x
state_after: case none
α : Type u_1
β : Type u_2
γ : Type u_3
e : Option α ≃ Option β
x : α
h : e (some x) = none
⊢ some (e.removeNone x) = e none ↔ e.symm none = some x

case some
α : Type u_1
β : Type u_2
γ : Type u_3
e : Option α ≃ Option β
x : α
a : β
h : e (some x) = some a
⊢ some (e.removeNone x) = e none ↔ e.symm none = some x

tactic: rw [removeNone_none _ h]
state_before: case none
α : Type u_1
β : Type u_2
γ : Type u_3
e : Option α ≃ Option β
x : α
h : e (some x) = none
⊢ some (e.removeNone x) = e none ↔ e.symm none = some x
state_after: case none
α : Type u_1
β : Type u_2
γ : Type u_3
e : Option α ≃ Option β
x : α
h : e (some x) = none
⊢ e none = e none ↔ e.symm none = some x

tactic: simpa using (congr_arg e.symm h).symm
state_before: case none
α : Type u_1
β : Type u_2
γ : Type u_3
e : Option α ≃ Option β
x : α
h : e (some x) = none
⊢ e none = e none ↔ e.symm none = some x
state_after: no goals

tactic: rw [removeNone_some _ ⟨a, h⟩]
state_before: case some
α : Type u_1
β : Type u_2
γ : Type u_3
e : Option α ≃ Option β
x : α
a : β
h : e (some x) = some a
⊢ some (e.removeNone x) = e none ↔ e.symm none = some x
state_after: case some
α : Type u_1
β : Type u_2
γ : Type u_3
e : Option α ≃ Option β
x : α
a : β
h : e (some x) = some a
⊢ e (some x) = e none ↔ e.symm none = some x

tactic: have h1 := congr_arg e.symm h
state_before: case some
α : Type u_1
β : Type u_2
γ : Type u_3
e : Option α ≃ Option β
x : α
a : β
h : e (some x) = some a
⊢ e (some x) = e none ↔ e.symm none = some x
state_after: case some
α : Type u_1
β : Type u_2
γ : Type u_3
e : Option α ≃ Option β
x : α
a : β
h : e (some x) = some a
h1 : e.symm (e (some x)) = e.symm (some a)
⊢ e (some x) = e none ↔ e.symm none = some x

tactic: rw [symm_apply_apply] at h1
state_before: case some
α : Type u_1
β : Type u_2
γ : Type u_3
e : Option α ≃ Option β
x : α
a : β
h : e (some x) = some a
h1 : e.symm (e (some x)) = e.symm (some a)
⊢ e (some x) = e none ↔ e.symm none = some x
state_after: case some
α : Type u_1
β : Type u_2
γ : Type u_3
e : Option α ≃ Option β
x : α
a : β
h : e (some x) = some a
h1 : some x = e.symm (some a)
⊢ e (some x) = e none ↔ e.symm none = some x

tactic: simp only [false_iff_iff, apply_eq_iff_eq]
state_before: case some
α : Type u_1
β : Type u_2
γ : Type u_3
e : Option α ≃ Option β
x : α
a : β
h : e (some x) = some a
h1 : some x = e.symm (some a)
⊢ e (some x) = e none ↔ e.symm none = some x
state_after: case some
α : Type u_1
β : Type u_2
γ : Type u_3
e : Option α ≃ Option β
x : α
a : β
h : e (some x) = some a
h1 : some x = e.symm (some a)
⊢ ¬e.symm none = some x

tactic: simp [h1, apply_eq_iff_eq]
state_before: case some
α : Type u_1
β : Type u_2
γ : Type u_3
e : Option α ≃ Option β
x : α
a : β
h : e (some x) = some a
h1 : some x = e.symm (some a)
⊢ ¬e.symm none = some x
state_after: no goals
Theorem: Matrix.conjTranspose_eq_diagonal
File: Mathlib/Data/Matrix/Basic.lean

tactic: rw [diagonal_conjTranspose]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : DecidableEq n
inst✝¹ : AddMonoid α
inst✝ : StarAddMonoid α
M : Matrix n n α
v : n → α
⊢ M = (diagonal v)ᴴ ↔ M = diagonal (star v)
state_after: no goals
Theorem: MeasureTheory.snorm_zero'
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

tactic: convert snorm_zero (F := F)
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
⊢ snorm (fun x => 0) p μ = 0
state_after: no goals
Theorem: Finset.sym2_nonempty
File: Mathlib/Data/Finset/Sym.lean

tactic: rw [← not_iff_not]
state_before: α : Type u_1
s t : Finset α
a b : α
⊢ s.sym2.Nonempty ↔ s.Nonempty
state_after: α : Type u_1
s t : Finset α
a b : α
⊢ ¬s.sym2.Nonempty ↔ ¬s.Nonempty

tactic: simp_rw [not_nonempty_iff_eq_empty, sym2_eq_empty]
state_before: α : Type u_1
s t : Finset α
a b : α
⊢ ¬s.sym2.Nonempty ↔ ¬s.Nonempty
state_after: no goals
Theorem: HomologicalComplex.inl_biprodXIso_inv
File: Mathlib/Algebra/Homology/HomologicalComplexBiprod.lean

tactic: simp [biprodXIso]
state_before: C : Type u_1
ι : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Preadditive C
c : ComplexShape ι
K L : HomologicalComplex C c
inst✝ : ∀ (i : ι), HasBinaryBiproduct (K.X i) (L.X i)
i : ι
⊢ biprod.inl ≫ (K.biprodXIso L i).inv = biprod.inl.f i
state_after: no goals