1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ONote.NF.of_dvd_omega_opow
File: Mathlib/SetTheory/Ordinal/Notation.lean

tactic: have := mt repr_inj.1 (fun h => by injection h : ONote.oadd e n a ≠ 0)
state_before: b : Ordinal.{0}
e : ONote
n : ℕ+
a : ONote
h : (e.oadd n a).NF
d : ω ^ b ∣ (e.oadd n a).repr
⊢ b ≤ e.repr ∧ ω ^ b ∣ a.repr
state_after: b : Ordinal.{0}
e : ONote
n : ℕ+
a : ONote
h : (e.oadd n a).NF
d : ω ^ b ∣ (e.oadd n a).repr
this : ¬(e.oadd n a).repr = repr 0
⊢ b ≤ e.repr ∧ ω ^ b ∣ a.repr

tactic: have L := le_of_not_lt fun l => not_le_of_lt (h.below_of_lt l).repr_lt (le_of_dvd this d)
state_before: b : Ordinal.{0}
e : ONote
n : ℕ+
a : ONote
h : (e.oadd n a).NF
d : ω ^ b ∣ (e.oadd n a).repr
this : ¬(e.oadd n a).repr = repr 0
⊢ b ≤ e.repr ∧ ω ^ b ∣ a.repr
state_after: b : Ordinal.{0}
e : ONote
n : ℕ+
a : ONote
h : (e.oadd n a).NF
d : ω ^ b ∣ (e.oadd n a).repr
this : ¬(e.oadd n a).repr = repr 0
L : b ≤ e.repr
⊢ b ≤ e.repr ∧ ω ^ b ∣ a.repr

tactic: simp only [repr] at d
state_before: b : Ordinal.{0}
e : ONote
n : ℕ+
a : ONote
h : (e.oadd n a).NF
d : ω ^ b ∣ (e.oadd n a).repr
this : ¬(e.oadd n a).repr = repr 0
L : b ≤ e.repr
⊢ b ≤ e.repr ∧ ω ^ b ∣ a.repr
state_after: b : Ordinal.{0}
e : ONote
n : ℕ+
a : ONote
h : (e.oadd n a).NF
d : ω ^ b ∣ ω ^ e.repr * ↑↑n + a.repr
this : ¬(e.oadd n a).repr = repr 0
L : b ≤ e.repr
⊢ b ≤ e.repr ∧ ω ^ b ∣ a.repr

tactic: exact ⟨L, (dvd_add_iff <| (opow_dvd_opow _ L).mul_right _).1 d⟩
state_before: b : Ordinal.{0}
e : ONote
n : ℕ+
a : ONote
h : (e.oadd n a).NF
d : ω ^ b ∣ ω ^ e.repr * ↑↑n + a.repr
this : ¬(e.oadd n a).repr = repr 0
L : b ≤ e.repr
⊢ b ≤ e.repr ∧ ω ^ b ∣ a.repr
state_after: no goals

tactic: injection h
state_before: b : Ordinal.{0}
e : ONote
n : ℕ+
a : ONote
h✝ : (e.oadd n a).NF
d : ω ^ b ∣ (e.oadd n a).repr
h : e.oadd n a = 0
⊢ False
state_after: no goals
Theorem: CategoryTheory.IsPullback.of_isLimit
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
c : PullbackCone f g
h : IsLimit c
⊢ c.fst = (Iso.refl c.pt).hom ≫ (PullbackCone.mk c.fst c.snd ⋯).fst
state_after: no goals

tactic: aesop_cat
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
c : PullbackCone f g
h : IsLimit c
⊢ c.snd = (Iso.refl c.pt).hom ≫ (PullbackCone.mk c.fst c.snd ⋯).snd
state_after: no goals
Theorem: Polynomial.tendsto_div_exp_atTop
File: Mathlib/Analysis/SpecialFunctions/PolynomialExp.lean

tactic: induction p using Polynomial.induction_on' with
| h_monomial n c => simpa [exp_neg, div_eq_mul_inv, mul_assoc]
  using tendsto_const_nhds.mul (tendsto_pow_mul_exp_neg_atTop_nhds_zero n)
| h_add p q hp hq => simpa [add_div] using hp.add hq
state_before: p : ℝ[X]
⊢ Tendsto (fun x => eval x p / rexp x) atTop (𝓝 0)
state_after: no goals

tactic: simpa [exp_neg, div_eq_mul_inv, mul_assoc]
using tendsto_const_nhds.mul (tendsto_pow_mul_exp_neg_atTop_nhds_zero n)
state_before: case h_monomial
n : ℕ
c : ℝ
⊢ Tendsto (fun x => eval x ((monomial n) c) / rexp x) atTop (𝓝 0)
state_after: no goals

tactic: simpa [add_div] using hp.add hq
state_before: case h_add
p q : ℝ[X]
hp : Tendsto (fun x => eval x p / rexp x) atTop (𝓝 0)
hq : Tendsto (fun x => eval x q / rexp x) atTop (𝓝 0)
⊢ Tendsto (fun x => eval x (p + q) / rexp x) atTop (𝓝 0)
state_after: no goals
Theorem: List.scanl_cons
File: Mathlib/Data/List/Basic.lean

tactic: simp only [scanl, eq_self_iff_true, singleton_append, and_self_iff]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : β → α → β
b : β
a : α
l : List α
⊢ scanl f b (a :: l) = [b] ++ scanl f (f b a) l
state_after: no goals
Theorem: measurableAtom_subset
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

tactic: simp [hs]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
inst✝ : MeasurableSpace β
s : Set β
x : β
hs : MeasurableSet s
hx : x ∈ s
a : β
⊢ a ∈ ⋂ (_ : MeasurableSet s), s → a ∈ s
state_after: no goals
Theorem: RingHom.isIntegralElem_map
File: Mathlib/RingTheory/IntegralClosure.lean

tactic: simp
state_before: R : Type u_1
S : Type u_2
A : Type u_3
inst✝³ : CommRing R
inst✝² : Ring A
inst✝¹ : Ring S
f : R →+* S
inst✝ : Algebra R A
x : R
⊢ eval₂ f (f x) (X - C x) = 0
state_after: no goals
Theorem: CategoryTheory.ShortComplex.RightHomologyMapData.opcyclesMap_comm
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

tactic: simp only [γ.opcyclesMap_eq, assoc, Iso.inv_hom_id, comp_id]
state_before: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.RightHomologyData
h₂ : S₂.RightHomologyData
γ : RightHomologyMapData φ h₁ h₂
inst✝¹ : S₁.HasRightHomology
inst✝ : S₂.HasRightHomology
⊢ opcyclesMap φ ≫ h₂.opcyclesIso.hom = h₁.opcyclesIso.hom ≫ γ.φQ
state_after: no goals
Theorem: Set.image2_eq_seq
File: Mathlib/Data/Set/Lattice.lean

tactic: rw [seq_eq_image2, image2_image_left]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β → γ
s : Set α
t : Set β
⊢ image2 f s t = (f '' s).seq t
state_after: no goals
Theorem: FirstOrder.Language.funMap_quotient_mk'
File: Mathlib/ModelTheory/Quotients.lean

tactic: change
  Quotient.map (@funMap L M ps.toStructure n f) Prestructure.fun_equiv (Quotient.finChoice _) =
    _
state_before: L : Language
M : Type u_1
s : Setoid M
ps : L.Prestructure s
n : ℕ
f : L.Functions n
x : Fin n → M
⊢ (funMap f fun i => ⟦x i⟧) = ⟦funMap f x⟧
state_after: L : Language
M : Type u_1
s : Setoid M
ps : L.Prestructure s
n : ℕ
f : L.Functions n
x : Fin n → M
⊢ Quotient.map (funMap f) ⋯ (Quotient.finChoice fun i => ⟦x i⟧) = ⟦funMap f x⟧

tactic: rw [Quotient.finChoice_eq, Quotient.map_mk]
state_before: L : Language
M : Type u_1
s : Setoid M
ps : L.Prestructure s
n : ℕ
f : L.Functions n
x : Fin n → M
⊢ Quotient.map (funMap f) ⋯ (Quotient.finChoice fun i => ⟦x i⟧) = ⟦funMap f x⟧
state_after: no goals
Theorem: cube_of_castHom_ne_zero
File: Mathlib/NumberTheory/FLT/Three.lean

tactic: norm_num
state_before: n : ZMod 9
⊢ 3 ∣ 9
state_after: no goals

tactic: revert n
state_before: n : ZMod 9
⊢ (castHom ⋯ (ZMod 3)) n ≠ 0 → n ^ 3 = 1 ∨ n ^ 3 = 8
state_after: ⊢ ∀ {n : ZMod 9}, (castHom ⋯ (ZMod 3)) n ≠ 0 → n ^ 3 = 1 ∨ n ^ 3 = 8

tactic: decide
state_before: ⊢ ∀ {n : ZMod 9}, (castHom ⋯ (ZMod 3)) n ≠ 0 → n ^ 3 = 1 ∨ n ^ 3 = 8
state_after: no goals
Theorem: Polynomial.degree_linear
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: rw [degree_add_eq_left_of_degree_lt <| degree_C_lt_degree_C_mul_X ha, degree_C_mul_X ha]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
ha : a ≠ 0
⊢ (C a * X + C b).degree = 1
state_after: no goals
Theorem: List.rdrop_append_length
File: Mathlib/Data/List/DropRight.lean

tactic: rw [rdrop_eq_reverse_drop_reverse, ← length_reverse l₂,
    reverse_append, drop_left, reverse_reverse]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
l₁ l₂ : List α
⊢ (l₁ ++ l₂).rdrop l₂.length = l₁
state_after: no goals
Theorem: PerfectClosure.iterate_frobenius_mk
File: Mathlib/FieldTheory/PerfectClosure.lean

tactic: induction' n with n ih
state_before: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
x : K
⊢ (⇑(frobenius (PerfectClosure K p) p))^[n] (mk K p (n, x)) = (of K p) x
state_after: case zero
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x : K
⊢ (⇑(frobenius (PerfectClosure K p) p))^[0] (mk K p (0, x)) = (of K p) x

case succ
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x : K
n : ℕ
ih : (⇑(frobenius (PerfectClosure K p) p))^[n] (mk K p (n, x)) = (of K p) x
⊢ (⇑(frobenius (PerfectClosure K p) p))^[n + 1] (mk K p (n + 1, x)) = (of K p) x

tactic: rw [iterate_succ_apply, ← ih, frobenius_mk, mk_succ_pow]
state_before: case succ
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x : K
n : ℕ
ih : (⇑(frobenius (PerfectClosure K p) p))^[n] (mk K p (n, x)) = (of K p) x
⊢ (⇑(frobenius (PerfectClosure K p) p))^[n + 1] (mk K p (n + 1, x)) = (of K p) x
state_after: no goals

tactic: rfl
state_before: case zero
K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x : K
⊢ (⇑(frobenius (PerfectClosure K p) p))^[0] (mk K p (0, x)) = (of K p) x
state_after: no goals
Theorem: Nat.ModEq.cancel_right_of_coprime
File: Mathlib/Data/Nat/ModEq.lean

tactic: simpa [mul_comm] using h
state_before: m n a b c d : ℕ
hmc : m.gcd c = 1
h : a * c ≡ b * c [MOD m]
⊢ c * a ≡ c * b [MOD m]
state_after: no goals
Theorem: HasFTaylorSeriesUpTo.zero_eq'
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

tactic: rw [← h.zero_eq x]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : HasFTaylorSeriesUpTo n f p
x : E
⊢ p x 0 = (continuousMultilinearCurryFin0 𝕜 E F).symm (f x)
state_after: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : HasFTaylorSeriesUpTo n f p
x : E
⊢ p x 0 = (continuousMultilinearCurryFin0 𝕜 E F).symm (p x 0).uncurry0

tactic: exact (p x 0).uncurry0_curry0.symm
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : HasFTaylorSeriesUpTo n f p
x : E
⊢ p x 0 = (continuousMultilinearCurryFin0 𝕜 E F).symm (p x 0).uncurry0
state_after: no goals
Theorem: equicontinuousOn_finite
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

tactic: simp only [EquicontinuousOn, equicontinuousWithinAt_finite, ContinuousOn, @forall_swap ι]
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
inst✝ : Finite ι
F : ι → X → α
S : Set X
⊢ EquicontinuousOn F S ↔ ∀ (i : ι), ContinuousOn (F i) S
state_after: no goals
Theorem: Fintype.card_filter_piFinset_eq_of_mem
File: Mathlib/Data/Fintype/BigOperators.lean

tactic: calc
  _ = ∏ j, (Function.update s i {a} j).card := by
    rw [← piFinset_update_singleton_eq_filter_piFinset_eq _ _ ha, Fintype.card_piFinset]
  _ = ∏ j, Function.update (fun j ↦ (s j).card) i 1 j :=
    Fintype.prod_congr _ _ fun j ↦ by obtain rfl | hji := eq_or_ne j i <;> simp [*]
  _ = _ := by simp [prod_update_of_mem, erase_eq]
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
κ : Type u_5
α : ι → Type u_6
inst✝³ : DecidableEq ι
inst✝² : DecidableEq κ
inst✝¹ : Fintype ι
inst✝ : (i : ι) → DecidableEq (α i)
s : (i : ι) → Finset (α i)
i : ι
a : α i
ha : a ∈ s i
⊢ (filter (fun f => f i = a) (piFinset s)).card = ∏ j ∈ univ.erase i, (s j).card
state_after: no goals

tactic: rw [← piFinset_update_singleton_eq_filter_piFinset_eq _ _ ha, Fintype.card_piFinset]
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
κ : Type u_5
α : ι → Type u_6
inst✝³ : DecidableEq ι
inst✝² : DecidableEq κ
inst✝¹ : Fintype ι
inst✝ : (i : ι) → DecidableEq (α i)
s : (i : ι) → Finset (α i)
i : ι
a : α i
ha : a ∈ s i
⊢ (filter (fun f => f i = a) (piFinset s)).card = ∏ j : ι, (Function.update s i {a} j).card
state_after: no goals

tactic: obtain rfl | hji := eq_or_ne j i <;> simp [*]
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
κ : Type u_5
α : ι → Type u_6
inst✝³ : DecidableEq ι
inst✝² : DecidableEq κ
inst✝¹ : Fintype ι
inst✝ : (i : ι) → DecidableEq (α i)
s : (i : ι) → Finset (α i)
i : ι
a : α i
ha : a ∈ s i
j : ι
⊢ (Function.update s i {a} j).card = Function.update (fun j => (s j).card) i 1 j
state_after: no goals

tactic: simp [prod_update_of_mem, erase_eq]
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
κ : Type u_5
α : ι → Type u_6
inst✝³ : DecidableEq ι
inst✝² : DecidableEq κ
inst✝¹ : Fintype ι
inst✝ : (i : ι) → DecidableEq (α i)
s : (i : ι) → Finset (α i)
i : ι
a : α i
ha : a ∈ s i
⊢ ∏ j : ι, Function.update (fun j => (s j).card) i 1 j = ∏ j ∈ univ.erase i, (s j).card
state_after: no goals
Theorem: Int.natMod_lt
File: Mathlib/Data/Int/Defs.lean

tactic: omega
state_before: a b c d m n✝ : ℤ
n : ℕ
hn : n ≠ 0
⊢ 0 < ↑n
state_after: no goals
Theorem: Polynomial.degree_gcd_le_right
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: rw [gcd_comm]
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p q : R[X]
hq : q ≠ 0
⊢ (gcd p q).degree ≤ q.degree
state_after: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p q : R[X]
hq : q ≠ 0
⊢ (gcd q p).degree ≤ q.degree

tactic: exact degree_gcd_le_left hq p
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p q : R[X]
hq : q ≠ 0
⊢ (gcd q p).degree ≤ q.degree
state_after: no goals
Theorem: MeasureTheory.Measure.haar_singleton
File: Mathlib/MeasureTheory/Group/Measure.lean

tactic: convert measure_preimage_mul μ g⁻¹ _
state_before: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁶ : MeasurableSpace G
inst✝⁵ : MeasurableSpace H
inst✝⁴ : Group G
inst✝³ : TopologicalSpace G
μ : Measure G
inst✝² : μ.IsHaarMeasure
inst✝¹ : TopologicalGroup G
inst✝ : BorelSpace G
g : G
⊢ μ {g} = μ {1}
state_after: case h.e'_2.h.e'_6
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁶ : MeasurableSpace G
inst✝⁵ : MeasurableSpace H
inst✝⁴ : Group G
inst✝³ : TopologicalSpace G
μ : Measure G
inst✝² : μ.IsHaarMeasure
inst✝¹ : TopologicalGroup G
inst✝ : BorelSpace G
g : G
⊢ {g} = (fun h => g⁻¹ * h) ⁻¹' {1}

tactic: simp only [mul_one, preimage_mul_left_singleton, inv_inv]
state_before: case h.e'_2.h.e'_6
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁶ : MeasurableSpace G
inst✝⁵ : MeasurableSpace H
inst✝⁴ : Group G
inst✝³ : TopologicalSpace G
μ : Measure G
inst✝² : μ.IsHaarMeasure
inst✝¹ : TopologicalGroup G
inst✝ : BorelSpace G
g : G
⊢ {g} = (fun h => g⁻¹ * h) ⁻¹' {1}
state_after: no goals
Theorem: EReal.inv_neg
File: Mathlib/Data/Real/EReal.lean

tactic: induction a
state_before: a : EReal
⊢ (-a)⁻¹ = -a⁻¹
state_after: case h_bot

⊢ (-⊥)⁻¹ = -⊥⁻¹

case h_real
a✝ : ℝ
⊢ (-↑a✝)⁻¹ = -(↑a✝)⁻¹

case h_top

⊢ (-⊤)⁻¹ = -⊤⁻¹

tactic: rw [neg_bot, inv_top, inv_bot, neg_zero]
state_before: case h_bot

⊢ (-⊥)⁻¹ = -⊥⁻¹
state_after: no goals

tactic: rw [← coe_inv _, ← coe_neg _⁻¹, ← coe_neg _, ← coe_inv (-_)]
state_before: case h_real
a✝ : ℝ
⊢ (-↑a✝)⁻¹ = -(↑a✝)⁻¹
state_after: case h_real
a✝ : ℝ
⊢ ↑(-a✝)⁻¹ = ↑(-a✝⁻¹)

tactic: exact EReal.coe_eq_coe_iff.2 _root_.inv_neg
state_before: case h_real
a✝ : ℝ
⊢ ↑(-a✝)⁻¹ = ↑(-a✝⁻¹)
state_after: no goals

tactic: rw [neg_top, inv_bot, inv_top, neg_zero]
state_before: case h_top

⊢ (-⊤)⁻¹ = -⊤⁻¹
state_after: no goals
Theorem: MeasureTheory.Measure.setLIntegral_condKernel_univ_right
File: Mathlib/Probability/Kernel/Disintegration/Integral.lean

tactic: rw [← setLIntegral_condKernel hf hs MeasurableSet.univ]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
ρ : Measure (β × Ω)
inst✝ : IsFiniteMeasure ρ
f : β × Ω → ℝ≥0∞
hf : Measurable f
s : Set β
hs : MeasurableSet s
⊢ ∫⁻ (b : β) in s, ∫⁻ (ω : Ω), f (b, ω) ∂ρ.condKernel b ∂ρ.fst = ∫⁻ (x : β × Ω) in s ×ˢ Set.univ, f x ∂ρ
state_after: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
ρ : Measure (β × Ω)
inst✝ : IsFiniteMeasure ρ
f : β × Ω → ℝ≥0∞
hf : Measurable f
s : Set β
hs : MeasurableSet s
⊢ ∫⁻ (b : β) in s, ∫⁻ (ω : Ω), f (b, ω) ∂ρ.condKernel b ∂ρ.fst =
    ∫⁻ (b : β) in s, ∫⁻ (ω : Ω) in Set.univ, f (b, ω) ∂ρ.condKernel b ∂ρ.fst

tactic: simp_rw [Measure.restrict_univ]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
ρ : Measure (β × Ω)
inst✝ : IsFiniteMeasure ρ
f : β × Ω → ℝ≥0∞
hf : Measurable f
s : Set β
hs : MeasurableSet s
⊢ ∫⁻ (b : β) in s, ∫⁻ (ω : Ω), f (b, ω) ∂ρ.condKernel b ∂ρ.fst =
    ∫⁻ (b : β) in s, ∫⁻ (ω : Ω) in Set.univ, f (b, ω) ∂ρ.condKernel b ∂ρ.fst
state_after: no goals
Theorem: EMetric.infEdist_image
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: simp only [infEdist, iInf_image, hΦ.edist_eq]
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x y : α
s t : Set α
Φ : α → β
hΦ : Isometry Φ
⊢ infEdist (Φ x) (Φ '' t) = infEdist x t
state_after: no goals
Theorem: PFun.coe_preimage
File: Mathlib/Data/PFun.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ι : Type u_6
f✝ : α →. β
f : α → β
s : Set β
⊢ (↑f).preimage s = f ⁻¹' s
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ι : Type u_6
f✝ : α →. β
f : α → β
s : Set β
x✝ : α
⊢ x✝ ∈ (↑f).preimage s ↔ x✝ ∈ f ⁻¹' s

tactic: simp
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ι : Type u_6
f✝ : α →. β
f : α → β
s : Set β
x✝ : α
⊢ x✝ ∈ (↑f).preimage s ↔ x✝ ∈ f ⁻¹' s
state_after: no goals
Theorem: Filter.EventuallyLE.cardinal_bUnion
File: Mathlib/Order/Filter/CardinalInter.lean

tactic: simp only [biUnion_eq_iUnion]
state_before: ι α β : Type u
c : Cardinal.{u}
l : Filter α
inst✝ : CardinalInterFilter l c
S : Set ι
hS : #↑S < c
s t : (i : ι) → i ∈ S → Set α
h : ∀ (i : ι) (hi : i ∈ S), s i hi ≤ᶠ[l] t i hi
⊢ ⋃ i, ⋃ (h : i ∈ S), s i h ≤ᶠ[l] ⋃ i, ⋃ (h : i ∈ S), t i h
state_after: ι α β : Type u
c : Cardinal.{u}
l : Filter α
inst✝ : CardinalInterFilter l c
S : Set ι
hS : #↑S < c
s t : (i : ι) → i ∈ S → Set α
h : ∀ (i : ι) (hi : i ∈ S), s i hi ≤ᶠ[l] t i hi
⊢ ⋃ x, s ↑x ⋯ ≤ᶠ[l] ⋃ x, t ↑x ⋯

tactic: exact EventuallyLE.cardinal_iUnion hS fun i => h i i.2
state_before: ι α β : Type u
c : Cardinal.{u}
l : Filter α
inst✝ : CardinalInterFilter l c
S : Set ι
hS : #↑S < c
s t : (i : ι) → i ∈ S → Set α
h : ∀ (i : ι) (hi : i ∈ S), s i hi ≤ᶠ[l] t i hi
⊢ ⋃ x, s ↑x ⋯ ≤ᶠ[l] ⋃ x, t ↑x ⋯
state_after: no goals
Theorem: Behrend.sum_eq
File: Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean

tactic: refine (Nat.div_eq_of_eq_mul_left zero_lt_two ?_).symm
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ ∑ i : Fin n, d * (2 * d + 1) ^ ↑i = ((2 * d + 1) ^ n - 1) / 2
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ (2 * d + 1) ^ n - 1 = (∑ i : Fin n, d * (2 * d + 1) ^ ↑i) * 2

tactic: rw [← sum_range fun i => d * (2 * d + 1) ^ (i : ℕ), ← mul_sum, mul_right_comm, mul_comm d, ←
  geom_sum_mul_add, add_tsub_cancel_right, mul_comm]
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
⊢ (2 * d + 1) ^ n - 1 = (∑ i : Fin n, d * (2 * d + 1) ^ ↑i) * 2
state_after: no goals
Theorem: iInf_eq_of_forall_le_of_tendsto
File: Mathlib/Topology/Algebra/Order/LiminfLimsup.lean

tactic: refine iInf_eq_of_forall_ge_of_forall_gt_exists_lt (fun i ↦ x_le i) ?_
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
S : Type u_5
π : ι → Type u_6
inst✝³ : CompleteLinearOrder R
inst✝² : TopologicalSpace R
inst✝¹ : OrderTopology R
x : R
as : ι → R
x_le : ∀ (i : ι), x ≤ as i
F : Filter ι
inst✝ : F.NeBot
as_lim : Tendsto as F (𝓝 x)
⊢ ⨅ i, as i = x
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
S : Type u_5
π : ι → Type u_6
inst✝³ : CompleteLinearOrder R
inst✝² : TopologicalSpace R
inst✝¹ : OrderTopology R
x : R
as : ι → R
x_le : ∀ (i : ι), x ≤ as i
F : Filter ι
inst✝ : F.NeBot
as_lim : Tendsto as F (𝓝 x)
⊢ ∀ (w : R), x < w → ∃ i, as i < w

tactic: apply fun w x_lt_w ↦ ‹Filter.NeBot F›.nonempty_of_mem (eventually_lt_of_tendsto_lt x_lt_w as_lim)
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
S : Type u_5
π : ι → Type u_6
inst✝³ : CompleteLinearOrder R
inst✝² : TopologicalSpace R
inst✝¹ : OrderTopology R
x : R
as : ι → R
x_le : ∀ (i : ι), x ≤ as i
F : Filter ι
inst✝ : F.NeBot
as_lim : Tendsto as F (𝓝 x)
⊢ ∀ (w : R), x < w → ∃ i, as i < w
state_after: no goals
Theorem: TendstoUniformlyOn.prod_map
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: rw [tendstoUniformlyOn_iff_tendstoUniformlyOnFilter] at h h' ⊢
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s'✝ : Set α
x : α
p : Filter ι
p'✝ : Filter α
g : ι → α
ι' : Type u_1
α' : Type u_2
β' : Type u_3
inst✝ : UniformSpace β'
F' : ι' → α' → β'
f' : α' → β'
p' : Filter ι'
s' : Set α'
h : TendstoUniformlyOn F f p s
h' : TendstoUniformlyOn F' f' p' s'
⊢ TendstoUniformlyOn (fun i => Prod.map (F i.1) (F' i.2)) (Prod.map f f') (p ×ˢ p') (s ×ˢ s')
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s'✝ : Set α
x : α
p : Filter ι
p'✝ : Filter α
g : ι → α
ι' : Type u_1
α' : Type u_2
β' : Type u_3
inst✝ : UniformSpace β'
F' : ι' → α' → β'
f' : α' → β'
p' : Filter ι'
s' : Set α'
h : TendstoUniformlyOnFilter F f p (𝓟 s)
h' : TendstoUniformlyOnFilter F' f' p' (𝓟 s')
⊢ TendstoUniformlyOnFilter (fun i => Prod.map (F i.1) (F' i.2)) (Prod.map f f') (p ×ˢ p') (𝓟 (s ×ˢ s'))

tactic: simpa only [prod_principal_principal] using h.prod_map h'
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s'✝ : Set α
x : α
p : Filter ι
p'✝ : Filter α
g : ι → α
ι' : Type u_1
α' : Type u_2
β' : Type u_3
inst✝ : UniformSpace β'
F' : ι' → α' → β'
f' : α' → β'
p' : Filter ι'
s' : Set α'
h : TendstoUniformlyOnFilter F f p (𝓟 s)
h' : TendstoUniformlyOnFilter F' f' p' (𝓟 s')
⊢ TendstoUniformlyOnFilter (fun i => Prod.map (F i.1) (F' i.2)) (Prod.map f f') (p ×ˢ p') (𝓟 (s ×ˢ s'))
state_after: no goals
Theorem: rothNumberNat_add_le
File: Mathlib/Combinatorics/Additive/AP/Three/Defs.lean

tactic: simp_rw [rothNumberNat_def]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
s : Finset ℕ
k n M N : ℕ
⊢ rothNumberNat (M + N) ≤ rothNumberNat M + rothNumberNat N
state_after: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
s : Finset ℕ
k n M N : ℕ
⊢ addRothNumber (range (M + N)) ≤ addRothNumber (range M) + addRothNumber (range N)

tactic: rw [range_add_eq_union, ← addRothNumber_map_add_left (range N) M]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
s : Finset ℕ
k n M N : ℕ
⊢ addRothNumber (range (M + N)) ≤ addRothNumber (range M) + addRothNumber (range N)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
s : Finset ℕ
k n M N : ℕ
⊢ addRothNumber (range M ∪ map (addLeftEmbedding M) (range N)) ≤
    addRothNumber (range M) + addRothNumber (map (addLeftEmbedding M) (range N))

tactic: exact addRothNumber_union_le _ _
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
s : Finset ℕ
k n M N : ℕ
⊢ addRothNumber (range M ∪ map (addLeftEmbedding M) (range N)) ≤
    addRothNumber (range M) + addRothNumber (map (addLeftEmbedding M) (range N))
state_after: no goals