1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Finset.image₂_subset
File: Mathlib/Data/Finset/NAry.lean

tactic: rw [← coe_subset, coe_image₂, coe_image₂]
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
hs : s ⊆ s'
ht : t ⊆ t'
⊢ image₂ f s t ⊆ image₂ f s' t'
state_after: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
hs : s ⊆ s'
ht : t ⊆ t'
⊢ image2 f ↑s ↑t ⊆ image2 f ↑s' ↑t'

tactic: exact image2_subset hs ht
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
hs : s ⊆ s'
ht : t ⊆ t'
⊢ image2 f ↑s ↑t ⊆ image2 f ↑s' ↑t'
state_after: no goals
Theorem: Finset.image_subset_image
File: Mathlib/Data/Finset/Image.lean

tactic: simp only [subset_def, image_val, subset_dedup', dedup_subset', Multiset.map_subset_map h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq β
f g : α → β
s : Finset α
t : Finset β
a : α
b c : β
s₁ s₂ : Finset α
h : s₁ ⊆ s₂
⊢ image f s₁ ⊆ image f s₂
state_after: no goals
Theorem: Mathlib.Meta.Positivity.pos_of_isNat
File: Mathlib/Tactic/Positivity/Core.lean

tactic: rw [NormNum.IsNat.to_eq h rfl]
state_before: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℕ
inst✝ : StrictOrderedSemiring A
h : NormNum.IsNat e n
w : Nat.ble 1 n = true
⊢ 0 < e
state_after: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℕ
inst✝ : StrictOrderedSemiring A
h : NormNum.IsNat e n
w : Nat.ble 1 n = true
⊢ 0 < ↑n

tactic: apply Nat.cast_pos.2
state_before: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℕ
inst✝ : StrictOrderedSemiring A
h : NormNum.IsNat e n
w : Nat.ble 1 n = true
⊢ 0 < ↑n
state_after: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℕ
inst✝ : StrictOrderedSemiring A
h : NormNum.IsNat e n
w : Nat.ble 1 n = true
⊢ 0 < n

tactic: simpa using w
state_before: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℕ
inst✝ : StrictOrderedSemiring A
h : NormNum.IsNat e n
w : Nat.ble 1 n = true
⊢ 0 < n
state_after: no goals
Theorem: CategoryTheory.Abelian.comp_coimage_π_eq_zero
File: Mathlib/CategoryTheory/Abelian/Basic.lean

tactic: simp [h]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Abelian C
P Q : C
f : P ⟶ Q
R : C
g : Q ⟶ R
h : f ≫ g = 0
⊢ (f ≫ coimage.π g) ≫ Abelian.factorThruCoimage g = 0
state_after: no goals
Theorem: exists_signed_sum
File: Mathlib/Data/Sign.lean

tactic: simp [ht]
state_before: α✝ α : Type u_1
inst✝ : DecidableEq α
s : Finset α
f : α → ℤ
β : Type u_1
t : Finset β
sgn : β → SignType
g : β → α
hg : ∀ (b : β), g b ∈ s
ht : t.card = ∑ a ∈ s, (f a).natAbs
hf : ∀ a ∈ s, (∑ b ∈ t, if g b = a then ↑(sgn b) else 0) = f a
⊢ Fintype.card { x // x ∈ t } = ∑ a ∈ s, (f a).natAbs
state_after: no goals
Theorem: StieltjesFunction.measure_Iic
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

tactic: refine tendsto_nhds_unique (tendsto_measure_Ioc_atBot _ _) ?_
state_before: f : StieltjesFunction
l : ℝ
hf : Tendsto (↑f) atBot (𝓝 l)
x : ℝ
⊢ f.measure (Iic x) = ofReal (↑f x - l)
state_after: f : StieltjesFunction
l : ℝ
hf : Tendsto (↑f) atBot (𝓝 l)
x : ℝ
⊢ Tendsto (fun x_1 => f.measure (Ioc x_1 x)) atBot (𝓝 (ofReal (↑f x - l)))

tactic: simp_rw [measure_Ioc]
state_before: f : StieltjesFunction
l : ℝ
hf : Tendsto (↑f) atBot (𝓝 l)
x : ℝ
⊢ Tendsto (fun x_1 => f.measure (Ioc x_1 x)) atBot (𝓝 (ofReal (↑f x - l)))
state_after: f : StieltjesFunction
l : ℝ
hf : Tendsto (↑f) atBot (𝓝 l)
x : ℝ
⊢ Tendsto (fun x_1 => ofReal (↑f x - ↑f x_1)) atBot (𝓝 (ofReal (↑f x - l)))

tactic: exact ENNReal.tendsto_ofReal (Tendsto.const_sub _ hf)
state_before: f : StieltjesFunction
l : ℝ
hf : Tendsto (↑f) atBot (𝓝 l)
x : ℝ
⊢ Tendsto (fun x_1 => ofReal (↑f x - ↑f x_1)) atBot (𝓝 (ofReal (↑f x - l)))
state_after: no goals
Theorem: iUnion_Ici_eq_Ioi_iInf
File: Mathlib/Order/Interval/Set/Disjoint.lean

tactic: simp only [← IsGLB.biUnion_Ici_eq_Ioi (@isGLB_iInf _ _ _ f) no_least_elem, mem_range,
  iUnion_exists, iUnion_iUnion_eq']
state_before: ι : Sort u
α : Type v
β : Type w
inst✝¹ : LinearOrder α
s : Set α
a : α
f✝ : ι → α
R : Type u_1
inst✝ : CompleteLinearOrder R
f : ι → R
no_least_elem : ⨅ i, f i ∉ range f
⊢ ⋃ i, Ici (f i) = Ioi (⨅ i, f i)
state_after: no goals
Theorem: CategoryTheory.Functor.CommShift.isoAdd_hom_app
File: Mathlib/CategoryTheory/Shift/CommShift.lean

tactic: simp only [isoAdd, isoAdd'_hom_app, shiftFunctorAdd'_eq_shiftFunctorAdd]
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝⁹ : Category.{u_7, u_1} C
inst✝⁸ : Category.{u_6, u_2} D
inst✝⁷ : Category.{?u.20890, u_3} E
F : C ⥤ D
G : D ⥤ E
A : Type u_4
B : Type u_5
inst✝⁶ : AddMonoid A
inst✝⁵ : AddCommMonoid B
inst✝⁴ : HasShift C A
inst✝³ : HasShift D A
inst✝² : HasShift E A
inst✝¹ : HasShift C B
inst✝ : HasShift D B
a b : A
e₁ : shiftFunctor C a ⋙ F ≅ F ⋙ shiftFunctor D a
e₂ : shiftFunctor C b ⋙ F ≅ F ⋙ shiftFunctor D b
X : C
⊢ (isoAdd e₁ e₂).hom.app X =
    F.map ((shiftFunctorAdd C a b).hom.app X) ≫
      e₂.hom.app ((shiftFunctor C a).obj X) ≫
        (shiftFunctor D b).map (e₁.hom.app X) ≫ (shiftFunctorAdd D a b).inv.app (F.obj X)
state_after: no goals
Theorem: MeasureTheory.Memℒp.integrable_norm_rpow
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: rw [← memℒp_one_iff_integrable]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
p : ℝ≥0∞
hf : Memℒp f p μ
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
⊢ Integrable (fun x => ‖f x‖ ^ p.toReal) μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
p : ℝ≥0∞
hf : Memℒp f p μ
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
⊢ Memℒp (fun x => ‖f x‖ ^ p.toReal) 1 μ

tactic: exact hf.norm_rpow hp_ne_zero hp_ne_top
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
p : ℝ≥0∞
hf : Memℒp f p μ
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
⊢ Memℒp (fun x => ‖f x‖ ^ p.toReal) 1 μ
state_after: no goals
Theorem: MeasureTheory.setLintegral_pos_iff
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [lintegral_pos_iff_support hf, Measure.restrict_apply (measurableSet_support hf)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
s : Set α
⊢ 0 < ∫⁻ (a : α) in s, f a ∂μ ↔ 0 < μ (support f ∩ s)
state_after: no goals
Theorem: LieAlgebra.IsKilling.ker_killingForm_eq_bot
File: Mathlib/Algebra/Lie/Killing.lean

tactic: simp [← LieIdeal.coe_killingCompl_top, killingCompl_top_eq_bot]
state_before: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : Field K
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : LieAlgebra K L
inst✝² : Module.Free R L
inst✝¹ : Module.Finite R L
inst✝ : IsKilling R L
⊢ LinearMap.ker (killingForm R L) = ⊥
state_after: no goals
Theorem: orthogonalProjection_minimal
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: rw [norm_eq_iInf_iff_inner_eq_zero _ (Submodule.coe_mem _)]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁶ : _root_.RCLike 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace 𝕜 E
inst✝² : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝¹ : HasOrthogonalProjection K
U : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection U
y : E
⊢ ‖y - ↑((orthogonalProjection U) y)‖ = ⨅ x, ‖y - ↑x‖
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁶ : _root_.RCLike 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace 𝕜 E
inst✝² : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝¹ : HasOrthogonalProjection K
U : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection U
y : E
⊢ ∀ w ∈ U, ⟪y - ↑((orthogonalProjection U) y), w⟫_𝕜 = 0

tactic: exact orthogonalProjection_inner_eq_zero _
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁶ : _root_.RCLike 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace 𝕜 E
inst✝² : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝¹ : HasOrthogonalProjection K
U : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection U
y : E
⊢ ∀ w ∈ U, ⟪y - ↑((orthogonalProjection U) y), w⟫_𝕜 = 0
state_after: no goals
Theorem: NNReal.nndist_eq
File: Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean

tactic: simp only [max_le_iff, tsub_le_iff_right (α := ℝ≥0)]
state_before: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
a b x✝ : ℝ≥0
⊢ nndist a b ≤ x✝ ↔ max (a - b) (b - a) ≤ x✝
state_after: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
a b x✝ : ℝ≥0
⊢ nndist a b ≤ x✝ ↔ a ≤ x✝ + b ∧ b ≤ x✝ + a

tactic: simp only [← NNReal.coe_le_coe, coe_nndist, dist_eq, abs_sub_le_iff,
  tsub_le_iff_right, NNReal.coe_add]
state_before: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
a b x✝ : ℝ≥0
⊢ nndist a b ≤ x✝ ↔ a ≤ x✝ + b ∧ b ≤ x✝ + a
state_after: no goals
Theorem: upperClosure_prod
File: Mathlib/Order/UpperLower/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set α
t : Set β
⊢ upperClosure (s ×ˢ t) = upperClosure s ×ˢ upperClosure t
state_after: case a.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set α
t : Set β
x✝ : α × β
⊢ x✝ ∈ ↑(upperClosure (s ×ˢ t)) ↔ x✝ ∈ ↑(upperClosure s ×ˢ upperClosure t)

tactic: simp [Prod.le_def, @and_and_and_comm _ (_ ∈ t)]
state_before: case a.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set α
t : Set β
x✝ : α × β
⊢ x✝ ∈ ↑(upperClosure (s ×ˢ t)) ↔ x✝ ∈ ↑(upperClosure s ×ˢ upperClosure t)
state_after: no goals
Theorem: legendreSym.quadratic_reciprocity'
File: Mathlib/NumberTheory/LegendreSymbol/QuadraticReciprocity.lean

tactic: rcases eq_or_ne p q with h | h
state_before: p q : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fact (Nat.Prime q)
hp : p ≠ 2
hq : q ≠ 2
⊢ legendreSym q ↑p = (-1) ^ (p / 2 * (q / 2)) * legendreSym p ↑q
state_after: case inl
p q : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fact (Nat.Prime q)
hp : p ≠ 2
hq : q ≠ 2
h : p = q
⊢ legendreSym q ↑p = (-1) ^ (p / 2 * (q / 2)) * legendreSym p ↑q

case inr
p q : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fact (Nat.Prime q)
hp : p ≠ 2
hq : q ≠ 2
h : p ≠ q
⊢ legendreSym q ↑p = (-1) ^ (p / 2 * (q / 2)) * legendreSym p ↑q

tactic: subst p
state_before: case inl
p q : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fact (Nat.Prime q)
hp : p ≠ 2
hq : q ≠ 2
h : p = q
⊢ legendreSym q ↑p = (-1) ^ (p / 2 * (q / 2)) * legendreSym p ↑q
state_after: case inl
q : ℕ
inst✝¹ : Fact (Nat.Prime q)
hq : q ≠ 2
inst✝ : Fact (Nat.Prime q)
hp : q ≠ 2
⊢ legendreSym q ↑q = (-1) ^ (q / 2 * (q / 2)) * legendreSym q ↑q

tactic: rw [(eq_zero_iff q q).mpr (mod_cast natCast_self q), mul_zero]
state_before: case inl
q : ℕ
inst✝¹ : Fact (Nat.Prime q)
hq : q ≠ 2
inst✝ : Fact (Nat.Prime q)
hp : q ≠ 2
⊢ legendreSym q ↑q = (-1) ^ (q / 2 * (q / 2)) * legendreSym q ↑q
state_after: no goals

tactic: have : ((q : ℤ) : ZMod p) ≠ 0 := mod_cast prime_ne_zero p q h
state_before: case inr
p q : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fact (Nat.Prime q)
hp : p ≠ 2
hq : q ≠ 2
h : p ≠ q
qr :
  (fun x => x * legendreSym p ↑q) (legendreSym q ↑p * legendreSym p ↑q) =
    (fun x => x * legendreSym p ↑q) ((-1) ^ (p / 2 * (q / 2)))
⊢ legendreSym q ↑p = (-1) ^ (p / 2 * (q / 2)) * legendreSym p ↑q
state_after: case inr
p q : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fact (Nat.Prime q)
hp : p ≠ 2
hq : q ≠ 2
h : p ≠ q
qr :
  (fun x => x * legendreSym p ↑q) (legendreSym q ↑p * legendreSym p ↑q) =
    (fun x => x * legendreSym p ↑q) ((-1) ^ (p / 2 * (q / 2)))
this : ↑↑q ≠ 0
⊢ legendreSym q ↑p = (-1) ^ (p / 2 * (q / 2)) * legendreSym p ↑q

tactic: simpa only [mul_assoc, ← pow_two, sq_one p this, mul_one] using qr
state_before: case inr
p q : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fact (Nat.Prime q)
hp : p ≠ 2
hq : q ≠ 2
h : p ≠ q
qr :
  (fun x => x * legendreSym p ↑q) (legendreSym q ↑p * legendreSym p ↑q) =
    (fun x => x * legendreSym p ↑q) ((-1) ^ (p / 2 * (q / 2)))
this : ↑↑q ≠ 0
⊢ legendreSym q ↑p = (-1) ^ (p / 2 * (q / 2)) * legendreSym p ↑q
state_after: no goals
Theorem: Real.sign_of_neg
File: Mathlib/Data/Real/Sign.lean

tactic: rw [sign, if_pos hr]
state_before: r : ℝ
hr : r < 0
⊢ r.sign = -1
state_after: no goals
Theorem: SimpleGraph.fromEdgeSet_edgeSet
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: ext v w
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
s : Set (Sym2 V)
⊢ fromEdgeSet G.edgeSet = G
state_after: case Adj.h.h.a
ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
s : Set (Sym2 V)
v w : V
⊢ (fromEdgeSet G.edgeSet).Adj v w ↔ G.Adj v w

tactic: exact ⟨fun h => h.1, fun h => ⟨h, G.ne_of_adj h⟩⟩
state_before: case Adj.h.h.a
ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
s : Set (Sym2 V)
v w : V
⊢ (fromEdgeSet G.edgeSet).Adj v w ↔ G.Adj v w
state_after: no goals
Theorem: CochainComplex.HomComplex.Cochain.map_ofHom
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

tactic: aesop_cat
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : Preadditive C
R : Type u_1
inst✝⁴ : Ring R
inst✝³ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
z z' : Cochain K L n
f : K ⟶ L
Φ : C ⥤ D
inst✝ : Φ.Additive
⊢ (ofHom f).map Φ = ofHom ((Φ.mapHomologicalComplex (ComplexShape.up ℤ)).map f)
state_after: no goals
Theorem: ENNReal.tsum_iUnion_le
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: rw [← tsum_fintype]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α → ℝ≥0∞
ι : Type u_4
inst✝ : Fintype ι
f : α → ℝ≥0∞
t : ι → Set α
⊢ ∑' (x : ↑(⋃ i, t i)), f ↑x ≤ ∑ i : ι, ∑' (x : ↑(t i)), f ↑x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α → ℝ≥0∞
ι : Type u_4
inst✝ : Fintype ι
f : α → ℝ≥0∞
t : ι → Set α
⊢ ∑' (x : ↑(⋃ i, t i)), f ↑x ≤ ∑' (b : ι) (x : ↑(t b)), f ↑x

tactic: exact tsum_iUnion_le_tsum f t
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α → ℝ≥0∞
ι : Type u_4
inst✝ : Fintype ι
f : α → ℝ≥0∞
t : ι → Set α
⊢ ∑' (x : ↑(⋃ i, t i)), f ↑x ≤ ∑' (b : ι) (x : ↑(t b)), f ↑x
state_after: no goals
Theorem: IsLocalizedModule.mk'_cancel'
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: rw [Submonoid.smul_def, ← mk'_smul, ← Submonoid.smul_def, mk'_cancel]
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
m : M
s : ↥S
⊢ s • mk' f m s = f m
state_after: no goals
Theorem: Batteries.RBNode.balRight_toList
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: unfold balRight
state_before: α : Type u_1
l : RBNode α
v : α
r : RBNode α
⊢ (l.balRight v r).toList = l.toList ++ v :: r.toList
state_after: α : Type u_1
l : RBNode α
v : α
r : RBNode α
⊢ (match r with
      | node red b y c => node red l v (node black b y c)
      | r =>
        match l with
        | node black a x b => (node red a x b).balance1 v r
        | node red a x (node black b y c) => node red (a.setRed.balance1 x b) y (node black c v r)
        | l => node red l v r).toList =
    l.toList ++ v :: r.toList

tactic: split <;> (try simp)
state_before: α : Type u_1
l : RBNode α
v : α
r : RBNode α
⊢ (match r with
      | node red b y c => node red l v (node black b y c)
      | r =>
        match l with
        | node black a x b => (node red a x b).balance1 v r
        | node red a x (node black b y c) => node red (a.setRed.balance1 x b) y (node black c v r)
        | l => node red l v r).toList =
    l.toList ++ v :: r.toList
state_after: case h_2
α : Type u_1
l : RBNode α
v : α
r l✝ : RBNode α
x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α), r = node red a x b → False
⊢ (match l with
      | node black a x b => (node red a x b).balance1 v r
      | node red a x (node black b y c) => node red (a.setRed.balance1 x b) y (node black c v r)
      | l => node red l v r).toList =
    l.toList ++ v :: r.toList

tactic: split <;> simp
state_before: case h_2
α : Type u_1
l : RBNode α
v : α
r l✝ : RBNode α
x✝ : ∀ (a : RBNode α) (x : α) (b : RBNode α), r = node red a x b → False
⊢ (match l with
      | node black a x b => (node red a x b).balance1 v r
      | node red a x (node black b y c) => node red (a.setRed.balance1 x b) y (node black c v r)
      | l => node red l v r).toList =
    l.toList ++ v :: r.toList
state_after: no goals

tactic: try simp
state_before: case h_1
α : Type u_1
l : RBNode α
v : α
l✝ a✝ : RBNode α
x✝ : α
b✝ : RBNode α
⊢ (node red l v (node black a✝ x✝ b✝)).toList = l.toList ++ v :: (node red a✝ x✝ b✝).toList
state_after: no goals

tactic: simp
state_before: case h_1
α : Type u_1
l : RBNode α
v : α
l✝ a✝ : RBNode α
x✝ : α
b✝ : RBNode α
⊢ (node red l v (node black a✝ x✝ b✝)).toList = l.toList ++ v :: (node red a✝ x✝ b✝).toList
state_after: no goals
Theorem: ENNReal.nhds_zero
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simp [pos_iff_ne_zero, Iio]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
⊢ ⨅ l, ⨅ (_ : ⊥ < l), 𝓟 (Iio l) = ⨅ a, ⨅ (_ : a ≠ 0), 𝓟 (Iio a)
state_after: no goals
Theorem: Matrix.updateRow_submatrix_equiv
File: Mathlib/Data/Matrix/RowCol.lean

tactic: ext i' j
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i✝ : m
j : n
b : n → α
c : m → α
inst✝¹ : DecidableEq l
inst✝ : DecidableEq m
A : Matrix m n α
i : l
r : o → α
e : l ≃ m
f : o ≃ n
⊢ (A.submatrix ⇑e ⇑f).updateRow i r = (A.updateRow (e i) fun j => r (f.symm j)).submatrix ⇑e ⇑f
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i✝ : m
j✝ : n
b : n → α
c : m → α
inst✝¹ : DecidableEq l
inst✝ : DecidableEq m
A : Matrix m n α
i : l
r : o → α
e : l ≃ m
f : o ≃ n
i' : l
j : o
⊢ (A.submatrix ⇑e ⇑f).updateRow i r i' j = (A.updateRow (e i) fun j => r (f.symm j)).submatrix (⇑e) (⇑f) i' j

tactic: simp only [submatrix_apply, updateRow_apply, Equiv.apply_eq_iff_eq, Equiv.symm_apply_apply]
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i✝ : m
j✝ : n
b : n → α
c : m → α
inst✝¹ : DecidableEq l
inst✝ : DecidableEq m
A : Matrix m n α
i : l
r : o → α
e : l ≃ m
f : o ≃ n
i' : l
j : o
⊢ (A.submatrix ⇑e ⇑f).updateRow i r i' j = (A.updateRow (e i) fun j => r (f.symm j)).submatrix (⇑e) (⇑f) i' j
state_after: no goals
Theorem: DiffContOnCl.two_pi_i_inv_smul_circleIntegral_sub_inv_smul
File: Mathlib/Analysis/Complex/CauchyIntegral.lean

tactic: have hR : 0 < R := not_le.mp (ball_eq_empty.not.mp (Set.nonempty_of_mem hw).ne_empty)
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
R : ℝ
c w : ℂ
f : ℂ → E
hf : DiffContOnCl ℂ f (ball c R)
hw : w ∈ ball c R
⊢ ((2 * ↑π * I)⁻¹ • ∮ (z : ℂ) in C(c, R), (z - w)⁻¹ • f z) = f w
state_after: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
R : ℝ
c w : ℂ
f : ℂ → E
hf : DiffContOnCl ℂ f (ball c R)
hw : w ∈ ball c R
hR : 0 < R
⊢ ((2 * ↑π * I)⁻¹ • ∮ (z : ℂ) in C(c, R), (z - w)⁻¹ • f z) = f w

tactic: refine two_pi_I_inv_smul_circleIntegral_sub_inv_smul_of_differentiable_on_off_countable
  countable_empty hw ?_ ?_
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
R : ℝ
c w : ℂ
f : ℂ → E
hf : DiffContOnCl ℂ f (ball c R)
hw : w ∈ ball c R
hR : 0 < R
⊢ ((2 * ↑π * I)⁻¹ • ∮ (z : ℂ) in C(c, R), (z - w)⁻¹ • f z) = f w
state_after: case refine_1
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
R : ℝ
c w : ℂ
f : ℂ → E
hf : DiffContOnCl ℂ f (ball c R)
hw : w ∈ ball c R
hR : 0 < R
⊢ ContinuousOn f (closedBall c R)

case refine_2
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
R : ℝ
c w : ℂ
f : ℂ → E
hf : DiffContOnCl ℂ f (ball c R)
hw : w ∈ ball c R
hR : 0 < R
⊢ ∀ x ∈ ball c R \ ∅, DifferentiableAt ℂ f x

tactic: simpa only [closure_ball c hR.ne.symm] using hf.continuousOn
state_before: case refine_1
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
R : ℝ
c w : ℂ
f : ℂ → E
hf : DiffContOnCl ℂ f (ball c R)
hw : w ∈ ball c R
hR : 0 < R
⊢ ContinuousOn f (closedBall c R)
state_after: no goals

tactic: simpa only [diff_empty] using fun z hz => hf.differentiableAt isOpen_ball hz
state_before: case refine_2
E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
R : ℝ
c w : ℂ
f : ℂ → E
hf : DiffContOnCl ℂ f (ball c R)
hw : w ∈ ball c R
hR : 0 < R
⊢ ∀ x ∈ ball c R \ ∅, DifferentiableAt ℂ f x
state_after: no goals