1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.OplaxMonoidalFunctor.δ_natural
File: Mathlib/CategoryTheory/Monoidal/Functor.lean

tactic: simp [tensorHom_def]
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : OplaxMonoidalFunctor C D
X Y X' Y' : C
f : X ⟶ Y
g : X' ⟶ Y'
⊢ F.δ X X' ≫ (F.map f ⊗ F.map g) = F.map (f ⊗ g) ≫ F.δ Y Y'
state_after: no goals
Theorem: CategoryTheory.CoverPreserving.comp
File: Mathlib/CategoryTheory/Sites/CoverPreserving.lean

tactic: rw [Sieve.functorPushforward_comp]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F✝ : C ⥤ D
A : Type u₃
inst✝ : Category.{v₃, u₃} A
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology A
F : C ⥤ D
hF : CoverPreserving J K F
G : D ⥤ A
hG : CoverPreserving K L G
U✝ : C
S✝ : Sieve U✝
hS : S✝ ∈ J.sieves U✝
⊢ Sieve.functorPushforward (F ⋙ G) S✝ ∈ L.sieves ((F ⋙ G).obj U✝)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F✝ : C ⥤ D
A : Type u₃
inst✝ : Category.{v₃, u₃} A
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology A
F : C ⥤ D
hF : CoverPreserving J K F
G : D ⥤ A
hG : CoverPreserving K L G
U✝ : C
S✝ : Sieve U✝
hS : S✝ ∈ J.sieves U✝
⊢ Sieve.functorPushforward G (Sieve.functorPushforward F S✝) ∈ L.sieves ((F ⋙ G).obj U✝)

tactic: exact hG.cover_preserve (hF.cover_preserve hS)
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F✝ : C ⥤ D
A : Type u₃
inst✝ : Category.{v₃, u₃} A
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology A
F : C ⥤ D
hF : CoverPreserving J K F
G : D ⥤ A
hG : CoverPreserving K L G
U✝ : C
S✝ : Sieve U✝
hS : S✝ ∈ J.sieves U✝
⊢ Sieve.functorPushforward G (Sieve.functorPushforward F S✝) ∈ L.sieves ((F ⋙ G).obj U✝)
state_after: no goals
Theorem: cauchySeq_of_edist_le_geometric
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: refine cauchySeq_of_edist_le_of_tsum_ne_top _ hu ?_
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoEMetricSpace α
r C : ℝ≥0∞
hr : r < 1
hC : C ≠ ⊤
f : ℕ → α
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * r ^ n
⊢ CauchySeq f
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoEMetricSpace α
r C : ℝ≥0∞
hr : r < 1
hC : C ≠ ⊤
f : ℕ → α
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * r ^ n
⊢ ∑' (n : ℕ), C * r ^ n ≠ ⊤

tactic: rw [ENNReal.tsum_mul_left, ENNReal.tsum_geometric]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoEMetricSpace α
r C : ℝ≥0∞
hr : r < 1
hC : C ≠ ⊤
f : ℕ → α
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * r ^ n
⊢ ∑' (n : ℕ), C * r ^ n ≠ ⊤
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoEMetricSpace α
r C : ℝ≥0∞
hr : r < 1
hC : C ≠ ⊤
f : ℕ → α
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * r ^ n
⊢ C * (1 - r)⁻¹ ≠ ⊤

tactic: refine ENNReal.mul_ne_top hC (ENNReal.inv_ne_top.2 ?_)
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoEMetricSpace α
r C : ℝ≥0∞
hr : r < 1
hC : C ≠ ⊤
f : ℕ → α
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * r ^ n
⊢ C * (1 - r)⁻¹ ≠ ⊤
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoEMetricSpace α
r C : ℝ≥0∞
hr : r < 1
hC : C ≠ ⊤
f : ℕ → α
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * r ^ n
⊢ 1 - r ≠ 0

tactic: exact (tsub_pos_iff_lt.2 hr).ne'
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : PseudoEMetricSpace α
r C : ℝ≥0∞
hr : r < 1
hC : C ≠ ⊤
f : ℕ → α
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * r ^ n
⊢ 1 - r ≠ 0
state_after: no goals
Theorem: HasFDerivWithinAt.smul_const
File: Mathlib/Analysis/Calculus/FDeriv/Mul.lean

tactic: simpa only [smul_zero, zero_add] using hc.smul (hasFDerivWithinAt_const f x s)
state_before: 𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type u_4
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
G' : Type u_5
inst✝⁵ : NormedAddCommGroup G'
inst✝⁴ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
𝕜' : Type u_6
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
c : E → 𝕜'
c' : E →L[𝕜] 𝕜'
hc : HasFDerivWithinAt c c' s x
f : F
⊢ HasFDerivWithinAt (fun y => c y • f) (c'.smulRight f) s x
state_after: no goals
Theorem: CategoryTheory.ComposableArrows.homMk₄_app_four
File: Mathlib/CategoryTheory/ComposableArrows.lean

tactic: valid
state_before: C : Type u_1
inst✝ : Category.{?u.324477, u_1} C
n m : ℕ
F G : ComposableArrows C n
f g : ComposableArrows C 4
app₀ : f.obj' 0 ⋯ ⟶ g.obj' 0 ⋯
app₁ : f.obj' 1 ⋯ ⟶ g.obj' 1 ⋯
app₂ : f.obj' 2 ⋯ ⟶ g.obj' 2 ⋯
app₃ : f.obj' 3 ⋯ ⟶ g.obj' 3 ⋯
app₄ : f.obj' 4 ⋯ ⟶ g.obj' 4 ⋯
w₀ : f.map' 0 1 ⋯ ⋯ ≫ app₁ = app₀ ≫ g.map' 0 1 ⋯ ⋯
w₁ : f.map' 1 2 ⋯ ⋯ ≫ app₂ = app₁ ≫ g.map' 1 2 ⋯ ⋯
w₂ : f.map' 2 3 ⋯ ⋯ ≫ app₃ = app₂ ≫ g.map' 2 3 ⋯ ⋯
w₃ : f.map' 3 4 ⋯ ⋯ ≫ app₄ = app₃ ≫ g.map' 3 4 ⋯ ⋯
⊢ 4 < 4 + 1
state_after: no goals
Theorem: isRelPrime_mul_unit_left
File: Mathlib/Algebra/Divisibility/Units.lean

tactic: rw [isRelPrime_mul_unit_left_left hu, isRelPrime_mul_unit_left_right hu]
state_before: α : Type u_1
inst✝ : CommMonoid α
x y z : α
hu : IsUnit x
⊢ IsRelPrime (x * y) (x * z) ↔ IsRelPrime y z
state_after: no goals
Theorem: Equiv.sigmaCongrRight_sigmaEquivProd
File: Mathlib/Logic/Equiv/Basic.lean

tactic: ext ⟨a, b⟩ : 1
state_before: α₁ : Type u_1
β₁ : Type u_3
β₂ : Type u_2
e : α₁ → β₁ ≃ β₂
⊢ (sigmaCongrRight e).trans (sigmaEquivProd α₁ β₂) = (sigmaEquivProd α₁ β₁).trans (prodCongrRight e)
state_after: case H.mk
α₁ : Type u_1
β₁ : Type u_3
β₂ : Type u_2
e : α₁ → β₁ ≃ β₂
a : α₁
b : β₁
⊢ ((sigmaCongrRight e).trans (sigmaEquivProd α₁ β₂)) ⟨a, b⟩ = ((sigmaEquivProd α₁ β₁).trans (prodCongrRight e)) ⟨a, b⟩

tactic: simp
state_before: case H.mk
α₁ : Type u_1
β₁ : Type u_3
β₂ : Type u_2
e : α₁ → β₁ ≃ β₂
a : α₁
b : β₁
⊢ ((sigmaCongrRight e).trans (sigmaEquivProd α₁ β₂)) ⟨a, b⟩ = ((sigmaEquivProd α₁ β₁).trans (prodCongrRight e)) ⟨a, b⟩
state_after: no goals
Theorem: Finset.erase_image_subset_image_erase
File: Mathlib/Data/Finset/Image.lean

tactic: simp only [subset_iff, and_imp, exists_prop, mem_image, exists_imp, mem_erase]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t : Finset β
a✝ : α
b c : β
inst✝ : DecidableEq α
f : α → β
s : Finset α
a : α
⊢ (image f s).erase (f a) ⊆ image f (s.erase a)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t : Finset β
a✝ : α
b c : β
inst✝ : DecidableEq α
f : α → β
s : Finset α
a : α
⊢ ∀ ⦃x : β⦄, x ≠ f a → ∀ x_1 ∈ s, f x_1 = x → ∃ a_4, (a_4 ≠ a ∧ a_4 ∈ s) ∧ f a_4 = x

tactic: rintro b hb x hx rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t : Finset β
a✝ : α
b c : β
inst✝ : DecidableEq α
f : α → β
s : Finset α
a : α
⊢ ∀ ⦃x : β⦄, x ≠ f a → ∀ x_1 ∈ s, f x_1 = x → ∃ a_4, (a_4 ≠ a ∧ a_4 ∈ s) ∧ f a_4 = x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t : Finset β
a✝ : α
b c : β
inst✝ : DecidableEq α
f : α → β
s : Finset α
a x : α
hx : x ∈ s
hb : f x ≠ f a
⊢ ∃ a_1, (a_1 ≠ a ∧ a_1 ∈ s) ∧ f a_1 = f x

tactic: exact ⟨_, ⟨ne_of_apply_ne f hb, hx⟩, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t : Finset β
a✝ : α
b c : β
inst✝ : DecidableEq α
f : α → β
s : Finset α
a x : α
hx : x ∈ s
hb : f x ≠ f a
⊢ ∃ a_1, (a_1 ≠ a ∧ a_1 ∈ s) ∧ f a_1 = f x
state_after: no goals
Theorem: QuadraticModuleCat.Hom.toIsometry_injective
File: Mathlib/LinearAlgebra/QuadraticForm/QuadraticModuleCat.lean

tactic: congr
state_before: R : Type u
inst✝ : CommRing R
V W : QuadraticModuleCat R
x✝² x✝¹ : V.Hom W
f g : V.form →qᵢ W.form
x✝ : { toIsometry := f }.toIsometry = { toIsometry := g }.toIsometry
⊢ { toIsometry := f } = { toIsometry := g }
state_after: no goals
Theorem: WittVector.polyOfInterest_vars_eq
File: Mathlib/RingTheory/WittVector/MulCoeff.lean

tactic: have : (p : 𝕄) ^ (n + 1) = C ((p : ℤ) ^ (n + 1)) := by norm_cast
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ (polyOfInterest p n).vars =
    (↑p ^ (n + 1) *
        (wittMul p (n + 1) + ↑p ^ (n + 1) * X (0, n + 1) * X (1, n + 1) -
            X (0, n + 1) * (rename (Prod.mk 1)) (wittPolynomial p ℤ (n + 1)) -
          X (1, n + 1) * (rename (Prod.mk 0)) (wittPolynomial p ℤ (n + 1)))).vars
state_after: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
this : ↑p ^ (n + 1) = C (↑p ^ (n + 1))
⊢ (polyOfInterest p n).vars =
    (↑p ^ (n + 1) *
        (wittMul p (n + 1) + ↑p ^ (n + 1) * X (0, n + 1) * X (1, n + 1) -
            X (0, n + 1) * (rename (Prod.mk 1)) (wittPolynomial p ℤ (n + 1)) -
          X (1, n + 1) * (rename (Prod.mk 0)) (wittPolynomial p ℤ (n + 1)))).vars

tactic: rw [polyOfInterest, this, vars_C_mul]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
this : ↑p ^ (n + 1) = C (↑p ^ (n + 1))
⊢ (polyOfInterest p n).vars =
    (↑p ^ (n + 1) *
        (wittMul p (n + 1) + ↑p ^ (n + 1) * X (0, n + 1) * X (1, n + 1) -
            X (0, n + 1) * (rename (Prod.mk 1)) (wittPolynomial p ℤ (n + 1)) -
          X (1, n + 1) * (rename (Prod.mk 0)) (wittPolynomial p ℤ (n + 1)))).vars
state_after: case ha
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
this : ↑p ^ (n + 1) = C (↑p ^ (n + 1))
⊢ ↑p ^ (n + 1) ≠ 0

tactic: apply pow_ne_zero
state_before: case ha
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
this : ↑p ^ (n + 1) = C (↑p ^ (n + 1))
⊢ ↑p ^ (n + 1) ≠ 0
state_after: case ha.h
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
this : ↑p ^ (n + 1) = C (↑p ^ (n + 1))
⊢ ↑p ≠ 0

tactic: exact mod_cast hp.out.ne_zero
state_before: case ha.h
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
this : ↑p ^ (n + 1) = C (↑p ^ (n + 1))
⊢ ↑p ≠ 0
state_after: no goals

tactic: norm_cast
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝ : CommRing k
n : ℕ
⊢ ↑p ^ (n + 1) = C (↑p ^ (n + 1))
state_after: no goals
Theorem: CategoryTheory.braiding_leftUnitor
File: Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean

tactic: rw [← whiskerRight_iff, comp_whiskerRight, braiding_leftUnitor_aux₂]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X : C
⊢ (β_ X (𝟙_ C)).hom ≫ (λ_ X).hom = (ρ_ X).hom
state_after: no goals
Theorem: OrderIso.map_atTop
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: rw [← e.comap_atTop, map_comap_of_surjective e.surjective]
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ≃o β
⊢ map (⇑e) atTop = atTop
state_after: no goals
Theorem: CategoryTheory.Limits.limit.id_pre
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: aesop_cat
state_before: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u
inst✝¹ : Category.{v, u} C
F✝ : J ⥤ C
inst✝ : HasLimitsOfShape J C
G : J ⥤ C
α : F✝ ⟶ G
F : J ⥤ C
⊢ pre F (𝟭 J) = lim.map F.leftUnitor.inv
state_after: no goals
Theorem: finprod_mem_mul_diff'
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: rw [← finprod_mem_inter_mul_diff' _ ht, inter_eq_self_of_subset_right hst]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Set α
hst : s ⊆ t
ht : (t ∩ mulSupport f).Finite
⊢ (∏ᶠ (i : α) (_ : i ∈ s), f i) * ∏ᶠ (i : α) (_ : i ∈ t \ s), f i = ∏ᶠ (i : α) (_ : i ∈ t), f i
state_after: no goals
Theorem: MvPolynomial.map_rename
File: Mathlib/Algebra/MvPolynomial/Rename.lean

tactic: apply MvPolynomial.induction_on p
  (fun a => by simp only [map_C, rename_C])
  (fun p q hp hq => by simp only [hp, hq, AlgHom.map_add, RingHom.map_add]) fun p n hp => by
  simp only [hp, rename_X, map_X, RingHom.map_mul, AlgHom.map_mul]
state_before: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
g : σ → τ
p : MvPolynomial σ R
⊢ (map f) ((rename g) p) = (rename g) ((map f) p)
state_after: no goals

tactic: simp only [map_C, rename_C]
state_before: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
g : σ → τ
p : MvPolynomial σ R
a : R
⊢ (map f) ((rename g) (C a)) = (rename g) ((map f) (C a))
state_after: no goals

tactic: simp only [hp, hq, AlgHom.map_add, RingHom.map_add]
state_before: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
g : σ → τ
p✝ p q : MvPolynomial σ R
hp : (map f) ((rename g) p) = (rename g) ((map f) p)
hq : (map f) ((rename g) q) = (rename g) ((map f) q)
⊢ (map f) ((rename g) (p + q)) = (rename g) ((map f) (p + q))
state_after: no goals

tactic: simp only [hp, rename_X, map_X, RingHom.map_mul, AlgHom.map_mul]
state_before: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
g : σ → τ
p✝ p : MvPolynomial σ R
n : σ
hp : (map f) ((rename g) p) = (rename g) ((map f) p)
⊢ (map f) ((rename g) (p * X n)) = (rename g) ((map f) (p * X n))
state_after: no goals
Theorem: BoxIntegral.Box.coe_mk'
File: Mathlib/Analysis/BoxIntegral/Box/Basic.lean

tactic: rw [mk']
state_before: ι : Type u_1
I J : Box ι
x y l u : ι → ℝ
⊢ ↑(mk' l u) = univ.pi fun i => Ioc (l i) (u i)
state_after: ι : Type u_1
I J : Box ι
x y l u : ι → ℝ
⊢ ↑(if h : ∀ (i : ι), l i < u i then ↑{ lower := l, upper := u, lower_lt_upper := h } else ⊥) =
    univ.pi fun i => Ioc (l i) (u i)

tactic: split_ifs with h
state_before: ι : Type u_1
I J : Box ι
x y l u : ι → ℝ
⊢ ↑(if h : ∀ (i : ι), l i < u i then ↑{ lower := l, upper := u, lower_lt_upper := h } else ⊥) =
    univ.pi fun i => Ioc (l i) (u i)
state_after: case pos
ι : Type u_1
I J : Box ι
x y l u : ι → ℝ
h : ∀ (i : ι), l i < u i
⊢ ↑↑{ lower := l, upper := u, lower_lt_upper := h } = univ.pi fun i => Ioc (l i) (u i)

case neg
ι : Type u_1
I J : Box ι
x y l u : ι → ℝ
h : ¬∀ (i : ι), l i < u i
⊢ ↑⊥ = univ.pi fun i => Ioc (l i) (u i)

tactic: exact coe_eq_pi _
state_before: case pos
ι : Type u_1
I J : Box ι
x y l u : ι → ℝ
h : ∀ (i : ι), l i < u i
⊢ ↑↑{ lower := l, upper := u, lower_lt_upper := h } = univ.pi fun i => Ioc (l i) (u i)
state_after: no goals

tactic: rcases not_forall.mp h with ⟨i, hi⟩
state_before: case neg
ι : Type u_1
I J : Box ι
x y l u : ι → ℝ
h : ¬∀ (i : ι), l i < u i
⊢ ↑⊥ = univ.pi fun i => Ioc (l i) (u i)
state_after: case neg.intro
ι : Type u_1
I J : Box ι
x y l u : ι → ℝ
h : ¬∀ (i : ι), l i < u i
i : ι
hi : ¬l i < u i
⊢ ↑⊥ = univ.pi fun i => Ioc (l i) (u i)

tactic: rw [coe_bot, univ_pi_eq_empty]
state_before: case neg.intro
ι : Type u_1
I J : Box ι
x y l u : ι → ℝ
h : ¬∀ (i : ι), l i < u i
i : ι
hi : ¬l i < u i
⊢ ↑⊥ = univ.pi fun i => Ioc (l i) (u i)
state_after: case neg.intro
ι : Type u_1
I J : Box ι
x y l u : ι → ℝ
h : ¬∀ (i : ι), l i < u i
i : ι
hi : ¬l i < u i
⊢ Ioc (l ?m.45508) (u ?m.45508) = ∅

ι : Type u_1
I J : Box ι
x y l u : ι → ℝ
h : ¬∀ (i : ι), l i < u i
i : ι
hi : ¬l i < u i
⊢ ι

tactic: exact Ioc_eq_empty hi
state_before: case neg.intro
ι : Type u_1
I J : Box ι
x y l u : ι → ℝ
h : ¬∀ (i : ι), l i < u i
i : ι
hi : ¬l i < u i
⊢ Ioc (l ?m.45508) (u ?m.45508) = ∅

ι : Type u_1
I J : Box ι
x y l u : ι → ℝ
h : ¬∀ (i : ι), l i < u i
i : ι
hi : ¬l i < u i
⊢ ι
state_after: no goals
Theorem: QPF.id_map
File: Mathlib/Data/QPF/Univariate/Basic.lean

tactic: rw [← abs_repr x]
state_before: F : Type u → Type u
q : QPF F
α : Type u
x : F α
⊢ id <$> x = x
state_after: F : Type u → Type u
q : QPF F
α : Type u
x : F α
⊢ id <$> abs (repr x) = abs (repr x)

tactic: cases' repr x with a f
state_before: F : Type u → Type u
q : QPF F
α : Type u
x : F α
⊢ id <$> abs (repr x) = abs (repr x)
state_after: case mk
F : Type u → Type u
q : QPF F
α : Type u
x : F α
a : (P F).A
f : (P F).B a → α
⊢ id <$> abs ⟨a, f⟩ = abs ⟨a, f⟩

tactic: rw [← abs_map]
state_before: case mk
F : Type u → Type u
q : QPF F
α : Type u
x : F α
a : (P F).A
f : (P F).B a → α
⊢ id <$> abs ⟨a, f⟩ = abs ⟨a, f⟩
state_after: case mk
F : Type u → Type u
q : QPF F
α : Type u
x : F α
a : (P F).A
f : (P F).B a → α
⊢ abs ((P F).map id ⟨a, f⟩) = abs ⟨a, f⟩

tactic: rfl
state_before: case mk
F : Type u → Type u
q : QPF F
α : Type u
x : F α
a : (P F).A
f : (P F).B a → α
⊢ abs ((P F).map id ⟨a, f⟩) = abs ⟨a, f⟩
state_after: no goals
Theorem: DirichletCharacter.changeLevel_self
File: Mathlib/NumberTheory/DirichletCharacter/Basic.lean

tactic: simp [changeLevel, ZMod.unitsMap]
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
n : ℕ
χ : DirichletCharacter R n
⊢ (changeLevel ⋯) χ = χ
state_after: no goals
Theorem: mem_connectedComponentIn
File: Mathlib/Topology/Connected/Basic.lean

tactic: simp [connectedComponentIn_eq_image hx, mem_connectedComponent, hx]
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F : Set α
hx : x ∈ F
⊢ x ∈ connectedComponentIn F x
state_after: no goals
Theorem: LSeries.term_congr
File: Mathlib/NumberTheory/LSeries/Basic.lean

tactic: rcases eq_or_ne n 0 with hn | hn <;> simp [hn, h]
state_before: f g : ℕ → ℂ
h : ∀ {n : ℕ}, n ≠ 0 → f n = g n
s : ℂ
n : ℕ
⊢ term f s n = term g s n
state_after: no goals
Theorem: SimpleGraph.girth_bot
File: Mathlib/Combinatorics/SimpleGraph/Girth.lean

tactic: simp
state_before: α : Type u_1
G : SimpleGraph α
n : ℕ∞
⊢ ⊥.girth = ⊤
state_after: no goals
Theorem: UniformFun.iInf_eq
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

tactic: ext : 1
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
u : ι → UniformSpace γ
⊢ uniformSpace α γ = ⨅ i, uniformSpace α γ
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
u : ι → UniformSpace γ
⊢ 𝓤 (α →ᵤ γ) = 𝓤 (α →ᵤ γ)

tactic: change UniformFun.filter α γ 𝓤[⨅ i, u i] = 𝓤[⨅ i, 𝒰(α, γ, u i)]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
u : ι → UniformSpace γ
⊢ 𝓤 (α →ᵤ γ) = 𝓤 (α →ᵤ γ)
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
u : ι → UniformSpace γ
⊢ UniformFun.filter α γ (𝓤 γ) = 𝓤 (α →ᵤ γ)

tactic: rw [iInf_uniformity, iInf_uniformity]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
u : ι → UniformSpace γ
⊢ UniformFun.filter α γ (𝓤 γ) = 𝓤 (α →ᵤ γ)
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
u : ι → UniformSpace γ
⊢ UniformFun.filter α γ (⨅ i, 𝓤 γ) = ⨅ i, 𝓤 (α →ᵤ γ)

tactic: exact (UniformFun.gc α γ).u_iInf
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
u : ι → UniformSpace γ
⊢ UniformFun.filter α γ (⨅ i, 𝓤 γ) = ⨅ i, 𝓤 (α →ᵤ γ)
state_after: no goals
Theorem: Submodule.sup_dualAnnihilator_le_inf
File: Mathlib/LinearAlgebra/Dual.lean

tactic: rw [le_dualAnnihilator_iff_le_dualCoannihilator, dualCoannihilator_sup_eq]
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W U V : Submodule R M
⊢ U.dualAnnihilator ⊔ V.dualAnnihilator ≤ (U ⊓ V).dualAnnihilator
state_after: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W U V : Submodule R M
⊢ U ⊓ V ≤ U.dualAnnihilator.dualCoannihilator ⊓ V.dualAnnihilator.dualCoannihilator

tactic: apply inf_le_inf <;> exact le_dualAnnihilator_dualCoannihilator _
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W U V : Submodule R M
⊢ U ⊓ V ≤ U.dualAnnihilator.dualCoannihilator ⊓ V.dualAnnihilator.dualCoannihilator
state_after: no goals
Theorem: BoxIntegral.Integrable.sum_integral_congr
File: Mathlib/Analysis/BoxIntegral/Basic.lean

tactic: refine tendsto_nhds_unique (h.tendsto_integralSum_sum_integral π₁) ?_
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝¹ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c c₁ c₂ : ℝ≥0
ε ε₁ ε₂ : ℝ
π₁✝ π₂✝ : TaggedPrepartition I
inst✝ : CompleteSpace F
h : Integrable I l f vol
π₁ π₂ : Prepartition I
hU : π₁.iUnion = π₂.iUnion
⊢ ∑ J ∈ π₁.boxes, integral J l f vol = ∑ J ∈ π₂.boxes, integral J l f vol
state_after: ι : Type u
E : Type v
F : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝¹ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c c₁ c₂ : ℝ≥0
ε ε₁ ε₂ : ℝ
π₁✝ π₂✝ : TaggedPrepartition I
inst✝ : CompleteSpace F
h : Integrable I l f vol
π₁ π₂ : Prepartition I
hU : π₁.iUnion = π₂.iUnion
⊢ Tendsto (integralSum f vol) (l.toFilteriUnion I π₁) (𝓝 (∑ J ∈ π₂.boxes, integral J l f vol))

tactic: rw [l.toFilteriUnion_congr _ hU]
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝¹ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c c₁ c₂ : ℝ≥0
ε ε₁ ε₂ : ℝ
π₁✝ π₂✝ : TaggedPrepartition I
inst✝ : CompleteSpace F
h : Integrable I l f vol
π₁ π₂ : Prepartition I
hU : π₁.iUnion = π₂.iUnion
⊢ Tendsto (integralSum f vol) (l.toFilteriUnion I π₁) (𝓝 (∑ J ∈ π₂.boxes, integral J l f vol))
state_after: ι : Type u
E : Type v
F : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝¹ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c c₁ c₂ : ℝ≥0
ε ε₁ ε₂ : ℝ
π₁✝ π₂✝ : TaggedPrepartition I
inst✝ : CompleteSpace F
h : Integrable I l f vol
π₁ π₂ : Prepartition I
hU : π₁.iUnion = π₂.iUnion
⊢ Tendsto (integralSum f vol) (l.toFilteriUnion I π₂) (𝓝 (∑ J ∈ π₂.boxes, integral J l f vol))

tactic: exact h.tendsto_integralSum_sum_integral π₂
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝¹ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c c₁ c₂ : ℝ≥0
ε ε₁ ε₂ : ℝ
π₁✝ π₂✝ : TaggedPrepartition I
inst✝ : CompleteSpace F
h : Integrable I l f vol
π₁ π₂ : Prepartition I
hU : π₁.iUnion = π₂.iUnion
⊢ Tendsto (integralSum f vol) (l.toFilteriUnion I π₂) (𝓝 (∑ J ∈ π₂.boxes, integral J l f vol))
state_after: no goals
Theorem: IsRelPrime.mul_left
File: Mathlib/Algebra/Divisibility/Units.lean

tactic: obtain ⟨a, b, ha, hb, rfl⟩ := exists_dvd_and_dvd_of_dvd_mul h
state_before: α : Type u_1
inst✝¹ : CommMonoid α
x y z : α
inst✝ : DecompositionMonoid α
H1 : IsRelPrime x z
H2 : IsRelPrime y z
x✝ : α
h : x✝ ∣ x * y
hz : x✝ ∣ z
⊢ IsUnit x✝
state_after: case intro.intro.intro.intro
α : Type u_1
inst✝¹ : CommMonoid α
x y z : α
inst✝ : DecompositionMonoid α
H1 : IsRelPrime x z
H2 : IsRelPrime y z
a b : α
ha : a ∣ x
hb : b ∣ y
h : a * b ∣ x * y
hz : a * b ∣ z
⊢ IsUnit (a * b)

tactic: exact (H1 ha <| (dvd_mul_right a b).trans hz).mul (H2 hb <| (dvd_mul_left b a).trans hz)
state_before: case intro.intro.intro.intro
α : Type u_1
inst✝¹ : CommMonoid α
x y z : α
inst✝ : DecompositionMonoid α
H1 : IsRelPrime x z
H2 : IsRelPrime y z
a b : α
ha : a ∣ x
hb : b ∣ y
h : a * b ∣ x * y
hz : a * b ∣ z
⊢ IsUnit (a * b)
state_after: no goals