1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ENNReal.limsup_mul_le
File: Mathlib/Order/Filter/ENNReal.lean

tactic: refine limsup_le_limsup ?_
state_before: α : Type u_1
f : Filter α
inst✝ : CountableInterFilter f
u v : α → ℝ≥0∞
⊢ limsup (u * v) f ≤ limsup (fun x => limsup u f * v x) f
state_after: α : Type u_1
f : Filter α
inst✝ : CountableInterFilter f
u v : α → ℝ≥0∞
⊢ u * v ≤ᶠ[f] fun x => limsup u f * v x

tactic: filter_upwards [@eventually_le_limsup _ f _ u] with x hx using mul_le_mul' hx le_rfl
state_before: α : Type u_1
f : Filter α
inst✝ : CountableInterFilter f
u v : α → ℝ≥0∞
⊢ u * v ≤ᶠ[f] fun x => limsup u f * v x
state_after: no goals
Theorem: Real.logb_mul
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: simp_rw [logb, log_mul hx hy, add_div]
state_before: b x y : ℝ
hx : x ≠ 0
hy : y ≠ 0
⊢ logb b (x * y) = logb b x + logb b y
state_after: no goals
Theorem: Quaternion.normSq_natCast
File: Mathlib/Algebra/Quaternion.lean

tactic: rw [← coe_natCast, normSq_coe]
state_before: S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
r x y z : R
a b c : ℍ[R]
n : ℕ
⊢ normSq ↑n = ↑n ^ 2
state_after: no goals
Theorem: Nat.prod_pow_factorization_choose
File: Mathlib/Data/Nat/Choose/Factorization.lean

tactic: conv => rhs
  rw [← factorization_prod_pow_eq_self (choose_pos hkn).ne']
state_before: p n✝ k✝ n k : ℕ
hkn : k ≤ n
⊢ ∏ p ∈ Finset.range (n + 1), p ^ (n.choose k).factorization p = n.choose k
state_after: p n✝ k✝ n k : ℕ
hkn : k ≤ n
⊢ ∏ p ∈ Finset.range (n + 1), p ^ (n.choose k).factorization p = (n.choose k).factorization.prod fun x x_1 => x ^ x_1

tactic: rw [eq_comm]
state_before: p n✝ k✝ n k : ℕ
hkn : k ≤ n
⊢ ∏ p ∈ Finset.range (n + 1), p ^ (n.choose k).factorization p = (n.choose k).factorization.prod fun x x_1 => x ^ x_1
state_after: p n✝ k✝ n k : ℕ
hkn : k ≤ n
⊢ ((n.choose k).factorization.prod fun x x_1 => x ^ x_1) = ∏ p ∈ Finset.range (n + 1), p ^ (n.choose k).factorization p

tactic: apply Finset.prod_subset
state_before: p n✝ k✝ n k : ℕ
hkn : k ≤ n
⊢ ((n.choose k).factorization.prod fun x x_1 => x ^ x_1) = ∏ p ∈ Finset.range (n + 1), p ^ (n.choose k).factorization p
state_after: case h
p n✝ k✝ n k : ℕ
hkn : k ≤ n
⊢ (n.choose k).factorization.support ⊆ Finset.range (n + 1)

case hf
p n✝ k✝ n k : ℕ
hkn : k ≤ n
⊢ ∀ x ∈ Finset.range (n + 1),
    x ∉ (n.choose k).factorization.support → (fun x x_1 => x ^ x_1) x ((n.choose k).factorization x) = 1

tactic: intro p hp
state_before: case h
p n✝ k✝ n k : ℕ
hkn : k ≤ n
⊢ (n.choose k).factorization.support ⊆ Finset.range (n + 1)
state_after: case h
p✝ n✝ k✝ n k : ℕ
hkn : k ≤ n
p : ℕ
hp : p ∈ (n.choose k).factorization.support
⊢ p ∈ Finset.range (n + 1)

tactic: rw [Finset.mem_range]
state_before: case h
p✝ n✝ k✝ n k : ℕ
hkn : k ≤ n
p : ℕ
hp : p ∈ (n.choose k).factorization.support
⊢ p ∈ Finset.range (n + 1)
state_after: case h
p✝ n✝ k✝ n k : ℕ
hkn : k ≤ n
p : ℕ
hp : p ∈ (n.choose k).factorization.support
⊢ p < n + 1

tactic: contrapose! hp
state_before: case h
p✝ n✝ k✝ n k : ℕ
hkn : k ≤ n
p : ℕ
hp : p ∈ (n.choose k).factorization.support
⊢ p < n + 1
state_after: case h
p✝ n✝ k✝ n k : ℕ
hkn : k ≤ n
p : ℕ
hp : n + 1 ≤ p
⊢ p ∉ (n.choose k).factorization.support

tactic: rw [Finsupp.mem_support_iff, Classical.not_not, factorization_choose_eq_zero_of_lt hp]
state_before: case h
p✝ n✝ k✝ n k : ℕ
hkn : k ≤ n
p : ℕ
hp : n + 1 ≤ p
⊢ p ∉ (n.choose k).factorization.support
state_after: no goals

tactic: intro p _ h2
state_before: case hf
p n✝ k✝ n k : ℕ
hkn : k ≤ n
⊢ ∀ x ∈ Finset.range (n + 1),
    x ∉ (n.choose k).factorization.support → (fun x x_1 => x ^ x_1) x ((n.choose k).factorization x) = 1
state_after: case hf
p✝ n✝ k✝ n k : ℕ
hkn : k ≤ n
p : ℕ
a✝ : p ∈ Finset.range (n + 1)
h2 : p ∉ (n.choose k).factorization.support
⊢ (fun x x_1 => x ^ x_1) p ((n.choose k).factorization p) = 1

tactic: simp [Classical.not_not.1 (mt Finsupp.mem_support_iff.2 h2)]
state_before: case hf
p✝ n✝ k✝ n k : ℕ
hkn : k ≤ n
p : ℕ
a✝ : p ∈ Finset.range (n + 1)
h2 : p ∉ (n.choose k).factorization.support
⊢ (fun x x_1 => x ^ x_1) p ((n.choose k).factorization p) = 1
state_after: no goals
Theorem: Nat.card_zmod
File: Mathlib/SetTheory/Cardinal/Finite.lean

tactic: cases n
state_before: α : Type u_1
β : Type u_2
n : ℕ
⊢ Nat.card (ZMod n) = n
state_after: case zero
α : Type u_1
β : Type u_2
⊢ Nat.card (ZMod 0) = 0

case succ
α : Type u_1
β : Type u_2
n✝ : ℕ
⊢ Nat.card (ZMod (n✝ + 1)) = n✝ + 1

tactic: exact @Nat.card_eq_zero_of_infinite _ Int.infinite
state_before: case zero
α : Type u_1
β : Type u_2
⊢ Nat.card (ZMod 0) = 0
state_after: no goals

tactic: rw [Nat.card_eq_fintype_card, ZMod.card]
state_before: case succ
α : Type u_1
β : Type u_2
n✝ : ℕ
⊢ Nat.card (ZMod (n✝ + 1)) = n✝ + 1
state_after: no goals
Theorem: UpperHalfPlane.exists_SL2_smul_eq_of_apply_zero_one_eq_zero
File: Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean

tactic: obtain ⟨a, b, ha, rfl⟩ := g.fin_two_exists_eq_mk_of_apply_zero_one_eq_zero hc
state_before: g : SL(2, ℝ)
hc : ↑↑g 1 0 = 0
⊢ ∃ u v, (fun x => g • x) = (fun x => v +ᵥ x) ∘ fun x => u • x
state_after: case intro.intro.intro
a b : ℝ
ha : a ≠ 0
hc : ↑↑⟨of ![![a, b], ![0, a⁻¹]], ⋯⟩ 1 0 = 0
⊢ ∃ u v, (fun x => ⟨of ![![a, b], ![0, a⁻¹]], ⋯⟩ • x) = (fun x => v +ᵥ x) ∘ fun x => u • x

tactic: refine ⟨⟨_, mul_self_pos.mpr ha⟩, b * a, ?_⟩
state_before: case intro.intro.intro
a b : ℝ
ha : a ≠ 0
hc : ↑↑⟨of ![![a, b], ![0, a⁻¹]], ⋯⟩ 1 0 = 0
⊢ ∃ u v, (fun x => ⟨of ![![a, b], ![0, a⁻¹]], ⋯⟩ • x) = (fun x => v +ᵥ x) ∘ fun x => u • x
state_after: case intro.intro.intro
a b : ℝ
ha : a ≠ 0
hc : ↑↑⟨of ![![a, b], ![0, a⁻¹]], ⋯⟩ 1 0 = 0
⊢ (fun x => ⟨of ![![a, b], ![0, a⁻¹]], ⋯⟩ • x) = (fun x => b * a +ᵥ x) ∘ fun x => ⟨a * a, ⋯⟩ • x

tactic: ext1 ⟨z, hz⟩
state_before: case intro.intro.intro
a b : ℝ
ha : a ≠ 0
hc : ↑↑⟨of ![![a, b], ![0, a⁻¹]], ⋯⟩ 1 0 = 0
⊢ (fun x => ⟨of ![![a, b], ![0, a⁻¹]], ⋯⟩ • x) = (fun x => b * a +ᵥ x) ∘ fun x => ⟨a * a, ⋯⟩ • x
state_after: case intro.intro.intro.h.mk
a b : ℝ
ha : a ≠ 0
hc : ↑↑⟨of ![![a, b], ![0, a⁻¹]], ⋯⟩ 1 0 = 0
z : ℂ
hz : 0 < z.im
⊢ ⟨of ![![a, b], ![0, a⁻¹]], ⋯⟩ • ⟨z, hz⟩ = ((fun x => b * a +ᵥ x) ∘ fun x => ⟨a * a, ⋯⟩ • x) ⟨z, hz⟩

tactic: ext1
state_before: case intro.intro.intro.h.mk
a b : ℝ
ha : a ≠ 0
hc : ↑↑⟨of ![![a, b], ![0, a⁻¹]], ⋯⟩ 1 0 = 0
z : ℂ
hz : 0 < z.im
⊢ ⟨of ![![a, b], ![0, a⁻¹]], ⋯⟩ • ⟨z, hz⟩ = ((fun x => b * a +ᵥ x) ∘ fun x => ⟨a * a, ⋯⟩ • x) ⟨z, hz⟩
state_after: case intro.intro.intro.h.mk.h
a b : ℝ
ha : a ≠ 0
hc : ↑↑⟨of ![![a, b], ![0, a⁻¹]], ⋯⟩ 1 0 = 0
z : ℂ
hz : 0 < z.im
⊢ ↑(⟨of ![![a, b], ![0, a⁻¹]], ⋯⟩ • ⟨z, hz⟩) = ↑(((fun x => b * a +ᵥ x) ∘ fun x => ⟨a * a, ⋯⟩ • x) ⟨z, hz⟩)

tactic: suffices ↑a * z * a + b * a = b * a + a * a * z by
  simpa [coeToGL, specialLinearGroup_apply, add_mul]
state_before: case intro.intro.intro.h.mk.h
a b : ℝ
ha : a ≠ 0
hc : ↑↑⟨of ![![a, b], ![0, a⁻¹]], ⋯⟩ 1 0 = 0
z : ℂ
hz : 0 < z.im
⊢ ↑(⟨of ![![a, b], ![0, a⁻¹]], ⋯⟩ • ⟨z, hz⟩) = ↑(((fun x => b * a +ᵥ x) ∘ fun x => ⟨a * a, ⋯⟩ • x) ⟨z, hz⟩)
state_after: case intro.intro.intro.h.mk.h
a b : ℝ
ha : a ≠ 0
hc : ↑↑⟨of ![![a, b], ![0, a⁻¹]], ⋯⟩ 1 0 = 0
z : ℂ
hz : 0 < z.im
⊢ ↑a * z * ↑a + ↑b * ↑a = ↑b * ↑a + ↑a * ↑a * z

tactic: ring
state_before: case intro.intro.intro.h.mk.h
a b : ℝ
ha : a ≠ 0
hc : ↑↑⟨of ![![a, b], ![0, a⁻¹]], ⋯⟩ 1 0 = 0
z : ℂ
hz : 0 < z.im
⊢ ↑a * z * ↑a + ↑b * ↑a = ↑b * ↑a + ↑a * ↑a * z
state_after: no goals

tactic: simpa [coeToGL, specialLinearGroup_apply, add_mul]
state_before: a b : ℝ
ha : a ≠ 0
hc : ↑↑⟨of ![![a, b], ![0, a⁻¹]], ⋯⟩ 1 0 = 0
z : ℂ
hz : 0 < z.im
this : ↑a * z * ↑a + ↑b * ↑a = ↑b * ↑a + ↑a * ↑a * z
⊢ ↑(⟨of ![![a, b], ![0, a⁻¹]], ⋯⟩ • ⟨z, hz⟩) = ↑(((fun x => b * a +ᵥ x) ∘ fun x => ⟨a * a, ⋯⟩ • x) ⟨z, hz⟩)
state_after: no goals
Theorem: CategoryTheory.Quotient.comp_left
File: Mathlib/CategoryTheory/Quotient.lean

tactic: simpa using CompClosure.intro (f ≫ x) m₁ m₂ y h
state_before: C : Type u_2
inst✝ : Category.{u_1, u_2} C
r : HomRel C
a b c : C
f : a ⟶ b
a✝ b✝ : C
x : b ⟶ a✝
m₁ m₂ : a✝ ⟶ b✝
y : b✝ ⟶ c
h : r m₁ m₂
⊢ CompClosure r (f ≫ x ≫ m₁ ≫ y) (f ≫ x ≫ m₂ ≫ y)
state_after: no goals
Theorem: CategoryTheory.OverPresheafAux.YonedaCollection.map₁_fst
File: Mathlib/CategoryTheory/Comma/Presheaf.lean

tactic: simp [map₁]
state_before: C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X : C
G : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
η : F ⟶ G
p : YonedaCollection F X
⊢ (map₁ η p).fst = p.fst
state_after: no goals
Theorem: Filter.comap_eq_of_inverse
File: Mathlib/Order/Filter/Basic.lean

tactic: refine ((comap_mono <| map_le_iff_le_comap.1 hψ).trans ?_).antisymm (map_le_iff_le_comap.1 hφ)
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : Filter β
φ : α → β
ψ : β → α
eq : ψ ∘ φ = id
hφ : Tendsto φ f g
hψ : Tendsto ψ g f
⊢ comap φ g = f
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : Filter β
φ : α → β
ψ : β → α
eq : ψ ∘ φ = id
hφ : Tendsto φ f g
hψ : Tendsto ψ g f
⊢ comap φ (comap ψ f) ≤ f

tactic: rw [comap_comap, eq, comap_id]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : Filter β
φ : α → β
ψ : β → α
eq : ψ ∘ φ = id
hφ : Tendsto φ f g
hψ : Tendsto ψ g f
⊢ comap φ (comap ψ f) ≤ f
state_after: no goals
Theorem: Fin.succAbove_pred_of_lt
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [succAbove_of_lt_succ _ _ (succ_pred _ _ ▸ h), succ_pred]
state_before: n m : ℕ
p✝ : Fin (n + 1)
i✝ j : Fin n
p i : Fin (n + 1)
h : p < i
hi : optParam (i ≠ 0) ⋯
⊢ p.succAbove (i.pred hi) = i
state_after: no goals
Theorem: nhdsSet_diagonal
File: Mathlib/Topology/NhdsSet.lean

tactic: rw [nhdsSet, ← range_diag, ← range_comp]
state_before: X✝ : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
f : Filter X✝
s t s₁ s₂ t₁ t₂ : Set X✝
x : X✝
X : Type u_3
inst✝ : TopologicalSpace (X × X)
⊢ 𝓝ˢ (diagonal X) = ⨆ x, 𝓝 (x, x)
state_after: X✝ : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
f : Filter X✝
s t s₁ s₂ t₁ t₂ : Set X✝
x : X✝
X : Type u_3
inst✝ : TopologicalSpace (X × X)
⊢ sSup (range (𝓝 ∘ fun x => (x, x))) = ⨆ x, 𝓝 (x, x)

tactic: rfl
state_before: X✝ : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
f : Filter X✝
s t s₁ s₂ t₁ t₂ : Set X✝
x : X✝
X : Type u_3
inst✝ : TopologicalSpace (X × X)
⊢ sSup (range (𝓝 ∘ fun x => (x, x))) = ⨆ x, 𝓝 (x, x)
state_after: no goals
Theorem: CategoryTheory.ShortComplex.exact_of_isZero_X₂
File: Mathlib/Algebra/Homology/ShortComplex/Exact.lean

tactic: rw [(HomologyData.ofZeros S (IsZero.eq_of_tgt h _ _) (IsZero.eq_of_src h _ _)).exact_iff]
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.11174, u_2} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
h : IsZero S.X₂
⊢ S.Exact
state_after: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.11174, u_2} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
h : IsZero S.X₂
⊢ IsZero (HomologyData.ofZeros S ⋯ ⋯).left.H

tactic: exact h
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.11174, u_2} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
h : IsZero S.X₂
⊢ IsZero (HomologyData.ofZeros S ⋯ ⋯).left.H
state_after: no goals
Theorem: CategoryTheory.Limits.KernelFork.IsLimit.isIso_ι
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

tactic: let e : c.pt ≅ X := IsLimit.conePointUniqueUpToIso hc
  (KernelFork.IsLimit.ofId (f : X ⟶ Y) hf)
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
X Y : C
f : X ⟶ Y
c : KernelFork f
hc : IsLimit c
hf : f = 0
⊢ IsIso (Fork.ι c)
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
X Y : C
f : X ⟶ Y
c : KernelFork f
hc : IsLimit c
hf : f = 0
e : c.pt ≅ X := hc.conePointUniqueUpToIso (ofId f hf)
⊢ IsIso (Fork.ι c)

tactic: have eq : e.inv ≫ c.ι = 𝟙 X := Fork.IsLimit.lift_ι hc
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
X Y : C
f : X ⟶ Y
c : KernelFork f
hc : IsLimit c
hf : f = 0
e : c.pt ≅ X := hc.conePointUniqueUpToIso (ofId f hf)
⊢ IsIso (Fork.ι c)
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
X Y : C
f : X ⟶ Y
c : KernelFork f
hc : IsLimit c
hf : f = 0
e : c.pt ≅ X := hc.conePointUniqueUpToIso (ofId f hf)
eq : e.inv ≫ Fork.ι c = 𝟙 X
⊢ IsIso (Fork.ι c)

tactic: haveI : IsIso (e.inv ≫ c.ι) := by
  rw [eq]
  infer_instance
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
X Y : C
f : X ⟶ Y
c : KernelFork f
hc : IsLimit c
hf : f = 0
e : c.pt ≅ X := hc.conePointUniqueUpToIso (ofId f hf)
eq : e.inv ≫ Fork.ι c = 𝟙 X
⊢ IsIso (Fork.ι c)
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
X Y : C
f : X ⟶ Y
c : KernelFork f
hc : IsLimit c
hf : f = 0
e : c.pt ≅ X := hc.conePointUniqueUpToIso (ofId f hf)
eq : e.inv ≫ Fork.ι c = 𝟙 X
this : IsIso (e.inv ≫ Fork.ι c)
⊢ IsIso (Fork.ι c)

tactic: exact IsIso.of_isIso_comp_left e.inv c.ι
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
X Y : C
f : X ⟶ Y
c : KernelFork f
hc : IsLimit c
hf : f = 0
e : c.pt ≅ X := hc.conePointUniqueUpToIso (ofId f hf)
eq : e.inv ≫ Fork.ι c = 𝟙 X
this : IsIso (e.inv ≫ Fork.ι c)
⊢ IsIso (Fork.ι c)
state_after: no goals

tactic: rw [eq]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
X Y : C
f : X ⟶ Y
c : KernelFork f
hc : IsLimit c
hf : f = 0
e : c.pt ≅ X := hc.conePointUniqueUpToIso (ofId f hf)
eq : e.inv ≫ Fork.ι c = 𝟙 X
⊢ IsIso (e.inv ≫ Fork.ι c)
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
X Y : C
f : X ⟶ Y
c : KernelFork f
hc : IsLimit c
hf : f = 0
e : c.pt ≅ X := hc.conePointUniqueUpToIso (ofId f hf)
eq : e.inv ≫ Fork.ι c = 𝟙 X
⊢ IsIso (𝟙 X)

tactic: infer_instance
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
X Y : C
f : X ⟶ Y
c : KernelFork f
hc : IsLimit c
hf : f = 0
e : c.pt ≅ X := hc.conePointUniqueUpToIso (ofId f hf)
eq : e.inv ≫ Fork.ι c = 𝟙 X
⊢ IsIso (𝟙 X)
state_after: no goals
Theorem: Encodable.decode_ofEquiv
File: Mathlib/Logic/Encodable/Basic.lean

tactic: rw [Option.map_eq_bind]
state_before: α✝ : Type u_1
β✝ : Type u_2
α : Type u_3
β : Type u_4
inst✝ : Encodable α
e : β ≃ α
n : ℕ
⊢ (decode n).bind (some ∘ ⇑e.symm) = Option.map (⇑e.symm) (decode n)
state_after: no goals
Theorem: induced_iff_nhds_eq
File: Mathlib/Topology/Order.lean

tactic: simp only [ext_iff_nhds, nhds_induced]
state_before: α : Type u
β : Type v
γ : Type u_1
f✝ : α → β
ι : Sort u_2
tα : TopologicalSpace α
tβ : TopologicalSpace β
f : β → α
⊢ tβ = induced f tα ↔ ∀ (b : β), 𝓝 b = comap f (𝓝 (f b))
state_after: no goals
Theorem: Asymptotics.IsEquivalent.tendsto_nhds
File: Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean

tactic: by_cases h : c = 0
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
huv : u ~[l] v
hu : Tendsto u l (𝓝 c)
⊢ Tendsto v l (𝓝 c)
state_after: case pos
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
huv : u ~[l] v
hu : Tendsto u l (𝓝 c)
h : c = 0
⊢ Tendsto v l (𝓝 c)

case neg
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
huv : u ~[l] v
hu : Tendsto u l (𝓝 c)
h : ¬c = 0
⊢ Tendsto v l (𝓝 c)

tactic: subst c
state_before: case pos
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
huv : u ~[l] v
hu : Tendsto u l (𝓝 c)
h : c = 0
⊢ Tendsto v l (𝓝 c)
state_after: case pos
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
huv : u ~[l] v
hu : Tendsto u l (𝓝 0)
⊢ Tendsto v l (𝓝 0)

tactic: rw [← isLittleO_one_iff ℝ] at hu ⊢
state_before: case pos
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
huv : u ~[l] v
hu : Tendsto u l (𝓝 0)
⊢ Tendsto v l (𝓝 0)
state_after: case pos
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
huv : u ~[l] v
hu : u =o[l] fun _x => 1
⊢ v =o[l] fun _x => 1

tactic: simpa using (huv.symm.isLittleO.trans hu).add hu
state_before: case pos
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
huv : u ~[l] v
hu : u =o[l] fun _x => 1
⊢ v =o[l] fun _x => 1
state_after: no goals

tactic: rw [← isEquivalent_const_iff_tendsto h] at hu ⊢
state_before: case neg
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
huv : u ~[l] v
hu : Tendsto u l (𝓝 c)
h : ¬c = 0
⊢ Tendsto v l (𝓝 c)
state_after: case neg
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
huv : u ~[l] v
hu : u ~[l] const α c
h : ¬c = 0
⊢ v ~[l] const α c

tactic: exact huv.symm.trans hu
state_before: case neg
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
huv : u ~[l] v
hu : u ~[l] const α c
h : ¬c = 0
⊢ v ~[l] const α c
state_after: no goals
Theorem: Complex.isCauSeq_conj
File: Mathlib/Data/Complex/Abs.lean

tactic: rw [← RingHom.map_sub, abs_conj]
state_before: f : CauSeq ℂ ⇑abs'
ε : ℝ
ε0 : ε > 0
i : ℕ
hi : ∀ j ≥ i, abs' (↑f j - ↑f i) < ε
j : ℕ
hj : j ≥ i
⊢ abs' ((fun n => (starRingEnd ℂ) (↑f n)) j - (fun n => (starRingEnd ℂ) (↑f n)) i) < ε
state_after: f : CauSeq ℂ ⇑abs'
ε : ℝ
ε0 : ε > 0
i : ℕ
hi : ∀ j ≥ i, abs' (↑f j - ↑f i) < ε
j : ℕ
hj : j ≥ i
⊢ abs' (↑f j - ↑f i) < ε

tactic: exact hi j hj
state_before: f : CauSeq ℂ ⇑abs'
ε : ℝ
ε0 : ε > 0
i : ℕ
hi : ∀ j ≥ i, abs' (↑f j - ↑f i) < ε
j : ℕ
hj : j ≥ i
⊢ abs' (↑f j - ↑f i) < ε
state_after: no goals
Theorem: Irrational.of_neg
File: Mathlib/Data/Real/Irrational.lean

tactic: rw [cast_neg, hx]
state_before: q✝ : ℚ
x y : ℝ
h : Irrational (-x)
x✝ : x ∈ Set.range Rat.cast
q : ℚ
hx : ↑q = x
⊢ ↑(-q) = -x
state_after: no goals
Theorem: TopCat.snd_embedding_of_left_embedding
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

tactic: convert (homeoOfIso (asIso (pullback.snd : pullback (𝟙 S) g ⟶ _))).embedding.comp
    (pullback_map_embedding_of_embeddings (i₂ := 𝟙 Y)
      f g (𝟙 S) g H (homeoOfIso (Iso.refl _)).embedding (𝟙 _) rfl (by simp))
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
H : Embedding ⇑f
g : Y ⟶ S
⊢ Embedding ⇑pullback.snd
state_after: case h.e'_5
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
H : Embedding ⇑f
g : Y ⟶ S
⊢ ⇑pullback.snd = ⇑(homeoOfIso (asIso pullback.snd)) ∘ ⇑(pullback.map f g (𝟙 S) g f (𝟙 Y) (𝟙 S) ⋯ ⋯)

tactic: erw [← coe_comp]
state_before: case h.e'_5
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
H : Embedding ⇑f
g : Y ⟶ S
⊢ ⇑pullback.snd = ⇑(homeoOfIso (asIso pullback.snd)) ∘ ⇑(pullback.map f g (𝟙 S) g f (𝟙 Y) (𝟙 S) ⋯ ⋯)
state_after: case h.e'_5
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
H : Embedding ⇑f
g : Y ⟶ S
⊢ ⇑pullback.snd = ⇑(pullback.map f g (𝟙 S) g f (𝟙 Y) (𝟙 S) ⋯ ⋯ ≫ (asIso pullback.snd).hom)

tactic: simp
state_before: case h.e'_5
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
H : Embedding ⇑f
g : Y ⟶ S
⊢ ⇑pullback.snd = ⇑(pullback.map f g (𝟙 S) g f (𝟙 Y) (𝟙 S) ⋯ ⋯ ≫ (asIso pullback.snd).hom)
state_after: no goals

tactic: simp
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
H : Embedding ⇑f
g : Y ⟶ S
⊢ g ≫ 𝟙 S = 𝟙 Y ≫ g
state_after: no goals
Theorem: MeasureTheory.IsFundamentalDomain.measure_eq
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

tactic: simpa only [setLIntegral_one] using hs.setLIntegral_eq ht (fun _ => 1) fun _ _ => rfl
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝¹⁰ : Group G
inst✝⁹ : Group H
inst✝⁸ : MulAction G α
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MulAction H β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : NormedAddCommGroup E
s t : Set α
μ : Measure α
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSMul G α
inst✝¹ : SMulInvariantMeasure G α μ
inst✝ : Countable G
ν : Measure α
hs : IsFundamentalDomain G s μ
ht : IsFundamentalDomain G t μ
⊢ μ s = μ t
state_after: no goals
Theorem: Set.ncard_diff_singleton_lt_of_mem
File: Mathlib/Data/Set/Card.lean

tactic: rw [← ncard_diff_singleton_add_one h hs]
state_before: α : Type u_1
β : Type u_2
s t : Set α
a : α
h : a ∈ s
hs : autoParam s.Finite _auto✝
⊢ (s \ {a}).ncard < s.ncard
state_after: α : Type u_1
β : Type u_2
s t : Set α
a : α
h : a ∈ s
hs : autoParam s.Finite _auto✝
⊢ (s \ {a}).ncard < (s \ {a}).ncard + 1

tactic: apply lt_add_one
state_before: α : Type u_1
β : Type u_2
s t : Set α
a : α
h : a ∈ s
hs : autoParam s.Finite _auto✝
⊢ (s \ {a}).ncard < (s \ {a}).ncard + 1
state_after: no goals
Theorem: Real.volume_pi_closedBall
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: simp only [MeasureTheory.volume_pi_closedBall a hr, volume_closedBall, Finset.prod_const]
state_before: ι : Type u_1
inst✝ : Fintype ι
a : ι → ℝ
r : ℝ
hr : 0 ≤ r
⊢ volume (Metric.closedBall a r) = ofReal ((2 * r) ^ Fintype.card ι)
state_after: ι : Type u_1
inst✝ : Fintype ι
a : ι → ℝ
r : ℝ
hr : 0 ≤ r
⊢ ofReal (2 * r) ^ Finset.univ.card = ofReal ((2 * r) ^ Fintype.card ι)

tactic: exact (ENNReal.ofReal_pow (mul_nonneg zero_le_two hr) _).symm
state_before: ι : Type u_1
inst✝ : Fintype ι
a : ι → ℝ
r : ℝ
hr : 0 ≤ r
⊢ ofReal (2 * r) ^ Finset.univ.card = ofReal ((2 * r) ^ Fintype.card ι)
state_after: no goals
Theorem: Homotopy.prevD_chainComplex
File: Mathlib/Algebra/Homology/Homotopy.lean

tactic: dsimp [prevD]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i : ι
P Q : ChainComplex V ℕ
f : (i j : ℕ) → P.X i ⟶ Q.X j
j : ℕ
⊢ (prevD j) f = f j (j + 1) ≫ Q.d (j + 1) j
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i : ι
P Q : ChainComplex V ℕ
f : (i j : ℕ) → P.X i ⟶ Q.X j
j : ℕ
⊢ f j ((ComplexShape.down ℕ).prev j) ≫ Q.d ((ComplexShape.down ℕ).prev j) j = f j (j + 1) ≫ Q.d (j + 1) j

tactic: have : (ComplexShape.down ℕ).prev j = j + 1 := ChainComplex.prev ℕ j
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i : ι
P Q : ChainComplex V ℕ
f : (i j : ℕ) → P.X i ⟶ Q.X j
j : ℕ
⊢ f j ((ComplexShape.down ℕ).prev j) ≫ Q.d ((ComplexShape.down ℕ).prev j) j = f j (j + 1) ≫ Q.d (j + 1) j
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i : ι
P Q : ChainComplex V ℕ
f : (i j : ℕ) → P.X i ⟶ Q.X j
j : ℕ
this : (ComplexShape.down ℕ).prev j = j + 1
⊢ f j ((ComplexShape.down ℕ).prev j) ≫ Q.d ((ComplexShape.down ℕ).prev j) j = f j (j + 1) ≫ Q.d (j + 1) j

tactic: congr 2
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i : ι
P Q : ChainComplex V ℕ
f : (i j : ℕ) → P.X i ⟶ Q.X j
j : ℕ
this : (ComplexShape.down ℕ).prev j = j + 1
⊢ f j ((ComplexShape.down ℕ).prev j) ≫ Q.d ((ComplexShape.down ℕ).prev j) j = f j (j + 1) ≫ Q.d (j + 1) j
state_after: no goals