1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Ordinal.zero_sub
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← Ordinal.le_zero]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal.{u_4}
⊢ 0 - a = 0
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal.{u_4}
⊢ 0 - a ≤ 0

tactic: apply sub_le_self
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal.{u_4}
⊢ 0 - a ≤ 0
state_after: no goals
Theorem: Polynomial.natTrailingDegree_neg
File: Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean

tactic: simp [natTrailingDegree]
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Ring R
p : R[X]
⊢ (-p).natTrailingDegree = p.natTrailingDegree
state_after: no goals
Theorem: Inducing.alexandrovDiscrete
File: Mathlib/Topology/AlexandrovDiscrete.lean

tactic: simp_rw [h.isOpen_iff] at hS ⊢
state_before: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
s t : Set α
a x y : α
inst✝¹ : AlexandrovDiscrete α
inst✝ : AlexandrovDiscrete β
f : β → α
h : Inducing f
S : Set (Set β)
hS : ∀ s ∈ S, IsOpen s
⊢ IsOpen (⋂₀ S)
state_after: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
s t : Set α
a x y : α
inst✝¹ : AlexandrovDiscrete α
inst✝ : AlexandrovDiscrete β
f : β → α
h : Inducing f
S : Set (Set β)
hS : ∀ s ∈ S, ∃ t, IsOpen t ∧ f ⁻¹' t = s
⊢ ∃ t, IsOpen t ∧ f ⁻¹' t = ⋂₀ S

tactic: choose U hU htU using hS
state_before: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
s t : Set α
a x y : α
inst✝¹ : AlexandrovDiscrete α
inst✝ : AlexandrovDiscrete β
f : β → α
h : Inducing f
S : Set (Set β)
hS : ∀ s ∈ S, ∃ t, IsOpen t ∧ f ⁻¹' t = s
⊢ ∃ t, IsOpen t ∧ f ⁻¹' t = ⋂₀ S
state_after: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
s t : Set α
a x y : α
inst✝¹ : AlexandrovDiscrete α
inst✝ : AlexandrovDiscrete β
f : β → α
h : Inducing f
S : Set (Set β)
U : (s : Set β) → s ∈ S → Set α
hU : ∀ (s : Set β) (a : s ∈ S), IsOpen (U s a)
htU : ∀ (s : Set β) (a : s ∈ S), f ⁻¹' U s a = s
⊢ ∃ t, IsOpen t ∧ f ⁻¹' t = ⋂₀ S

tactic: refine ⟨_, isOpen_iInter₂ hU, ?_⟩
state_before: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
s t : Set α
a x y : α
inst✝¹ : AlexandrovDiscrete α
inst✝ : AlexandrovDiscrete β
f : β → α
h : Inducing f
S : Set (Set β)
U : (s : Set β) → s ∈ S → Set α
hU : ∀ (s : Set β) (a : s ∈ S), IsOpen (U s a)
htU : ∀ (s : Set β) (a : s ∈ S), f ⁻¹' U s a = s
⊢ ∃ t, IsOpen t ∧ f ⁻¹' t = ⋂₀ S
state_after: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
s t : Set α
a x y : α
inst✝¹ : AlexandrovDiscrete α
inst✝ : AlexandrovDiscrete β
f : β → α
h : Inducing f
S : Set (Set β)
U : (s : Set β) → s ∈ S → Set α
hU : ∀ (s : Set β) (a : s ∈ S), IsOpen (U s a)
htU : ∀ (s : Set β) (a : s ∈ S), f ⁻¹' U s a = s
⊢ f ⁻¹' ⋂ i, ⋂ (j : i ∈ S), U i j = ⋂₀ S

tactic: simp_rw [preimage_iInter, htU, sInter_eq_biInter]
state_before: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
s t : Set α
a x y : α
inst✝¹ : AlexandrovDiscrete α
inst✝ : AlexandrovDiscrete β
f : β → α
h : Inducing f
S : Set (Set β)
U : (s : Set β) → s ∈ S → Set α
hU : ∀ (s : Set β) (a : s ∈ S), IsOpen (U s a)
htU : ∀ (s : Set β) (a : s ∈ S), f ⁻¹' U s a = s
⊢ f ⁻¹' ⋂ i, ⋂ (j : i ∈ S), U i j = ⋂₀ S
state_after: no goals
Theorem: div_eq_div_iff_div_eq_div'
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: conv_lhs => rw [← mul_left_inj' hb, div_mul_cancel₀ _ hb]
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝¹ : MonoidWithZero M₀
inst✝ : CommGroupWithZero G₀
a b c d : G₀
hb : b ≠ 0
hc : c ≠ 0
⊢ a / b = c / d ↔ a / c = b / d
state_after: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝¹ : MonoidWithZero M₀
inst✝ : CommGroupWithZero G₀
a b c d : G₀
hb : b ≠ 0
hc : c ≠ 0
⊢ a = c / d * b ↔ a / c = b / d

tactic: conv_rhs => rw [← mul_left_inj' hc, div_mul_cancel₀ _ hc]
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝¹ : MonoidWithZero M₀
inst✝ : CommGroupWithZero G₀
a b c d : G₀
hb : b ≠ 0
hc : c ≠ 0
⊢ a = c / d * b ↔ a / c = b / d
state_after: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝¹ : MonoidWithZero M₀
inst✝ : CommGroupWithZero G₀
a b c d : G₀
hb : b ≠ 0
hc : c ≠ 0
⊢ a = c / d * b ↔ a = b / d * c

tactic: rw [mul_comm _ c, div_mul_eq_mul_div, mul_div_assoc]
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝¹ : MonoidWithZero M₀
inst✝ : CommGroupWithZero G₀
a b c d : G₀
hb : b ≠ 0
hc : c ≠ 0
⊢ a = c / d * b ↔ a = b / d * c
state_after: no goals
Theorem: divp_eq_div
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [div_eq_mul_inv, divp, u.val_inv_eq_inv_val]
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
a : α
u : αˣ
⊢ a /ₚ u = a / ↑u
state_after: no goals
Theorem: Bool.bne_eq_xor
File: Mathlib/Data/Bool/Basic.lean

tactic: funext a b
state_before: ⊢ bne = xor
state_after: case h.h
a b : Bool
⊢ (a != b) = xor a b

tactic: revert a b
state_before: case h.h
a b : Bool
⊢ (a != b) = xor a b
state_after: case h.h

⊢ ∀ (a b : Bool), (a != b) = xor a b

tactic: decide
state_before: case h.h

⊢ ∀ (a b : Bool), (a != b) = xor a b
state_after: no goals
Theorem: Associates.factors_one
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: apply eq_of_prod_eq_prod
state_before: α : Type u_1
inst✝⁴ : CancelCommMonoidWithZero α
inst✝³ : UniqueFactorizationMonoid α
inst✝² : DecidableEq (Associates α)
inst✝¹ : (p : Associates α) → Decidable (Irreducible p)
inst✝ : Nontrivial α
⊢ factors 1 = 0
state_after: case h
α : Type u_1
inst✝⁴ : CancelCommMonoidWithZero α
inst✝³ : UniqueFactorizationMonoid α
inst✝² : DecidableEq (Associates α)
inst✝¹ : (p : Associates α) → Decidable (Irreducible p)
inst✝ : Nontrivial α
⊢ (factors 1).prod = FactorSet.prod 0

tactic: rw [Associates.factors_prod]
state_before: case h
α : Type u_1
inst✝⁴ : CancelCommMonoidWithZero α
inst✝³ : UniqueFactorizationMonoid α
inst✝² : DecidableEq (Associates α)
inst✝¹ : (p : Associates α) → Decidable (Irreducible p)
inst✝ : Nontrivial α
⊢ (factors 1).prod = FactorSet.prod 0
state_after: case h
α : Type u_1
inst✝⁴ : CancelCommMonoidWithZero α
inst✝³ : UniqueFactorizationMonoid α
inst✝² : DecidableEq (Associates α)
inst✝¹ : (p : Associates α) → Decidable (Irreducible p)
inst✝ : Nontrivial α
⊢ 1 = FactorSet.prod 0

tactic: exact Multiset.prod_zero
state_before: case h
α : Type u_1
inst✝⁴ : CancelCommMonoidWithZero α
inst✝³ : UniqueFactorizationMonoid α
inst✝² : DecidableEq (Associates α)
inst✝¹ : (p : Associates α) → Decidable (Irreducible p)
inst✝ : Nontrivial α
⊢ 1 = FactorSet.prod 0
state_after: no goals
Theorem: CommGroup.nilpotencyClass_le_one
File: Mathlib/GroupTheory/Nilpotent.lean

tactic: rw [← upperCentralSeries_eq_top_iff_nilpotencyClass_le, upperCentralSeries_one]
state_before: G✝ : Type u_1
inst✝² : Group G✝
H : Subgroup G✝
inst✝¹ : H.Normal
G : Type u_2
inst✝ : CommGroup G
⊢ Group.nilpotencyClass G ≤ 1
state_after: G✝ : Type u_1
inst✝² : Group G✝
H : Subgroup G✝
inst✝¹ : H.Normal
G : Type u_2
inst✝ : CommGroup G
⊢ center G = ⊤

tactic: apply CommGroup.center_eq_top
state_before: G✝ : Type u_1
inst✝² : Group G✝
H : Subgroup G✝
inst✝¹ : H.Normal
G : Type u_2
inst✝ : CommGroup G
⊢ center G = ⊤
state_after: no goals
Theorem: Matrix.dotProduct_comp_equiv_symm
File: Mathlib/Data/Matrix/Basic.lean

tactic: simpa only [Equiv.symm_symm] using (comp_equiv_symm_dotProduct u x e.symm).symm
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
x y : n → α
e : n ≃ m
⊢ u ⬝ᵥ x ∘ ⇑e.symm = u ∘ ⇑e ⬝ᵥ x
state_after: no goals
Theorem: Set.image_neg_Ioc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ Neg.neg '' Ioc a b = Ico (-b) (-a)
state_after: no goals
Theorem: List.replicate_dedup
File: Mathlib/Data/List/Dedup.lean

tactic: rw [replicate_succ, dedup_cons_of_mem (mem_replicate.2 ⟨n.succ_ne_zero, rfl⟩),
  replicate_dedup n.succ_ne_zero]
state_before: α : Type u
inst✝ : DecidableEq α
x : α
n : ℕ
x✝ : n + 2 ≠ 0
⊢ (replicate (n + 2) x).dedup = [x]
state_after: no goals
Theorem: CategoryTheory.monoidalOfHasFiniteProducts.associator_hom_snd_snd
File: Mathlib/CategoryTheory/Monoidal/OfHasFiniteProducts.lean

tactic: simp [associator_hom]
state_before: C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ : C
inst✝¹ : HasTerminal C
inst✝ : HasBinaryProducts C
X Y Z : C
⊢ (α_ X Y Z).hom ≫ prod.snd ≫ prod.snd = prod.snd
state_after: no goals
Theorem: IsAntichain.max_minimals
File: Mathlib/Order/Minimal.lean

tactic: refine h.antisymm fun a ha => ?_
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a b : α
ht : IsAntichain r t
h : minimals r s ⊆ t
hs : ∀ ⦃a : α⦄, a ∈ t → ∃ b ∈ minimals r s, r a b
⊢ minimals r s = t
state_after: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b : α
ht : IsAntichain r t
h : minimals r s ⊆ t
hs : ∀ ⦃a : α⦄, a ∈ t → ∃ b ∈ minimals r s, r a b
a : α
ha : a ∈ t
⊢ a ∈ minimals r s

tactic: obtain ⟨b, hb, hr⟩ := hs ha
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b : α
ht : IsAntichain r t
h : minimals r s ⊆ t
hs : ∀ ⦃a : α⦄, a ∈ t → ∃ b ∈ minimals r s, r a b
a : α
ha : a ∈ t
⊢ a ∈ minimals r s
state_after: case intro.intro
α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b✝ : α
ht : IsAntichain r t
h : minimals r s ⊆ t
hs : ∀ ⦃a : α⦄, a ∈ t → ∃ b ∈ minimals r s, r a b
a : α
ha : a ∈ t
b : α
hb : b ∈ minimals r s
hr : r a b
⊢ a ∈ minimals r s

tactic: rwa [of_not_not fun hab => ht ha (h hb) hab hr]
state_before: case intro.intro
α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b✝ : α
ht : IsAntichain r t
h : minimals r s ⊆ t
hs : ∀ ⦃a : α⦄, a ∈ t → ∃ b ∈ minimals r s, r a b
a : α
ha : a ∈ t
b : α
hb : b ∈ minimals r s
hr : r a b
⊢ a ∈ minimals r s
state_after: no goals
Theorem: ascPochhammer_eval_zero
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: cases n
state_before: S : Type u
inst✝ : Semiring S
n : ℕ
⊢ eval 0 (ascPochhammer S n) = if n = 0 then 1 else 0
state_after: case zero
S : Type u
inst✝ : Semiring S
⊢ eval 0 (ascPochhammer S 0) = if 0 = 0 then 1 else 0

case succ
S : Type u
inst✝ : Semiring S
n✝ : ℕ
⊢ eval 0 (ascPochhammer S (n✝ + 1)) = if n✝ + 1 = 0 then 1 else 0

tactic: simp
state_before: case zero
S : Type u
inst✝ : Semiring S
⊢ eval 0 (ascPochhammer S 0) = if 0 = 0 then 1 else 0
state_after: no goals

tactic: simp [X_mul, Nat.succ_ne_zero, ascPochhammer_succ_left]
state_before: case succ
S : Type u
inst✝ : Semiring S
n✝ : ℕ
⊢ eval 0 (ascPochhammer S (n✝ + 1)) = if n✝ + 1 = 0 then 1 else 0
state_after: no goals
Theorem: lt_div_iff'
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [mul_comm, lt_div_iff hc]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hc : 0 < c
⊢ a < b / c ↔ c * a < b
state_after: no goals
Theorem: dvd_zero
File: Mathlib/Algebra/GroupWithZero/Divisibility.lean

tactic: simp
state_before: α : Type u_1
inst✝ : SemigroupWithZero α
a✝ a : α
⊢ a * 0 = 0
state_after: no goals
Theorem: AffineMap.restrict.injective
File: Mathlib/LinearAlgebra/AffineSpace/Restrict.lean

tactic: intro x y h
state_before: k : Type u_1
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
inst✝⁸ : Ring k
inst✝⁷ : AddCommGroup V₁
inst✝⁶ : AddCommGroup V₂
inst✝⁵ : Module k V₁
inst✝⁴ : Module k V₂
inst✝³ : AddTorsor V₁ P₁
inst✝² : AddTorsor V₂ P₂
φ : P₁ →ᵃ[k] P₂
hφ : Function.Injective ⇑φ
E : AffineSubspace k P₁
F : AffineSubspace k P₂
inst✝¹ : Nonempty ↥E
inst✝ : Nonempty ↥F
hEF : AffineSubspace.map φ E ≤ F
⊢ Function.Injective ⇑(φ.restrict hEF)
state_after: k : Type u_1
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
inst✝⁸ : Ring k
inst✝⁷ : AddCommGroup V₁
inst✝⁶ : AddCommGroup V₂
inst✝⁵ : Module k V₁
inst✝⁴ : Module k V₂
inst✝³ : AddTorsor V₁ P₁
inst✝² : AddTorsor V₂ P₂
φ : P₁ →ᵃ[k] P₂
hφ : Function.Injective ⇑φ
E : AffineSubspace k P₁
F : AffineSubspace k P₂
inst✝¹ : Nonempty ↥E
inst✝ : Nonempty ↥F
hEF : AffineSubspace.map φ E ≤ F
x y : ↥E
h : (φ.restrict hEF) x = (φ.restrict hEF) y
⊢ x = y

tactic: simp only [Subtype.ext_iff, Subtype.coe_mk, AffineMap.restrict.coe_apply] at h ⊢
state_before: k : Type u_1
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
inst✝⁸ : Ring k
inst✝⁷ : AddCommGroup V₁
inst✝⁶ : AddCommGroup V₂
inst✝⁵ : Module k V₁
inst✝⁴ : Module k V₂
inst✝³ : AddTorsor V₁ P₁
inst✝² : AddTorsor V₂ P₂
φ : P₁ →ᵃ[k] P₂
hφ : Function.Injective ⇑φ
E : AffineSubspace k P₁
F : AffineSubspace k P₂
inst✝¹ : Nonempty ↥E
inst✝ : Nonempty ↥F
hEF : AffineSubspace.map φ E ≤ F
x y : ↥E
h : (φ.restrict hEF) x = (φ.restrict hEF) y
⊢ x = y
state_after: k : Type u_1
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
inst✝⁸ : Ring k
inst✝⁷ : AddCommGroup V₁
inst✝⁶ : AddCommGroup V₂
inst✝⁵ : Module k V₁
inst✝⁴ : Module k V₂
inst✝³ : AddTorsor V₁ P₁
inst✝² : AddTorsor V₂ P₂
φ : P₁ →ᵃ[k] P₂
hφ : Function.Injective ⇑φ
E : AffineSubspace k P₁
F : AffineSubspace k P₂
inst✝¹ : Nonempty ↥E
inst✝ : Nonempty ↥F
hEF : AffineSubspace.map φ E ≤ F
x y : ↥E
h : φ ↑x = φ ↑y
⊢ ↑x = ↑y

tactic: exact hφ h
state_before: k : Type u_1
V₁ : Type u_2
P₁ : Type u_3
V₂ : Type u_4
P₂ : Type u_5
inst✝⁸ : Ring k
inst✝⁷ : AddCommGroup V₁
inst✝⁶ : AddCommGroup V₂
inst✝⁵ : Module k V₁
inst✝⁴ : Module k V₂
inst✝³ : AddTorsor V₁ P₁
inst✝² : AddTorsor V₂ P₂
φ : P₁ →ᵃ[k] P₂
hφ : Function.Injective ⇑φ
E : AffineSubspace k P₁
F : AffineSubspace k P₂
inst✝¹ : Nonempty ↥E
inst✝ : Nonempty ↥F
hEF : AffineSubspace.map φ E ≤ F
x y : ↥E
h : φ ↑x = φ ↑y
⊢ ↑x = ↑y
state_after: no goals
Theorem: AdjoinRoot.root_isInv
File: Mathlib/RingTheory/AdjoinRoot.lean

tactic: convert sub_eq_zero.1 ((eval₂_sub _).symm.trans <| eval₂_root <| C r * X - 1) <;>
  simp only [eval₂_mul, eval₂_C, eval₂_X, eval₂_one]
state_before: R : Type u
S : Type v
K : Type w
inst✝² : CommRing R
f : R[X]
inst✝¹ : CommRing S
i : R →+* S
a : S
h : eval₂ i a f = 0
inst✝ : Algebra R S
hfx : (aeval a) f = 0
r : R
⊢ (of (C r * X - 1)) r * root (C r * X - 1) = 1
state_after: no goals
Theorem: Polynomial.count_roots_le_one
File: Mathlib/FieldTheory/Separable.lean

tactic: rw [count_roots p]
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R[X]
hsep : p.Separable
x : R
⊢ Multiset.count x p.roots ≤ 1
state_after: R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R[X]
hsep : p.Separable
x : R
⊢ rootMultiplicity x p ≤ 1

tactic: exact rootMultiplicity_le_one_of_separable hsep x
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R[X]
hsep : p.Separable
x : R
⊢ rootMultiplicity x p ≤ 1
state_after: no goals
Theorem: MeasureTheory.Measure.measurable_lintegral
File: Mathlib/MeasureTheory/Measure/GiryMonad.lean

tactic: simp only [lintegral_eq_iSup_eapprox_lintegral, hf, SimpleFunc.lintegral]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : α → ℝ≥0∞
hf : Measurable f
⊢ Measurable fun μ => ∫⁻ (x : α), f x ∂μ
state_after: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : α → ℝ≥0∞
hf : Measurable f
⊢ Measurable fun μ => ⨆ n, ∑ x ∈ (SimpleFunc.eapprox f n).range, x * μ (↑(SimpleFunc.eapprox f n) ⁻¹' {x})

tactic: refine measurable_iSup fun n => Finset.measurable_sum _ fun i _ => ?_
state_before: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : α → ℝ≥0∞
hf : Measurable f
⊢ Measurable fun μ => ⨆ n, ∑ x ∈ (SimpleFunc.eapprox f n).range, x * μ (↑(SimpleFunc.eapprox f n) ⁻¹' {x})
state_after: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : α → ℝ≥0∞
hf : Measurable f
n : ℕ
i : ℝ≥0∞
x✝ : i ∈ (SimpleFunc.eapprox f n).range
⊢ Measurable fun μ => i * μ (↑(SimpleFunc.eapprox f n) ⁻¹' {i})

tactic: refine Measurable.const_mul ?_ _
state_before: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : α → ℝ≥0∞
hf : Measurable f
n : ℕ
i : ℝ≥0∞
x✝ : i ∈ (SimpleFunc.eapprox f n).range
⊢ Measurable fun μ => i * μ (↑(SimpleFunc.eapprox f n) ⁻¹' {i})
state_after: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : α → ℝ≥0∞
hf : Measurable f
n : ℕ
i : ℝ≥0∞
x✝ : i ∈ (SimpleFunc.eapprox f n).range
⊢ Measurable fun μ => μ (↑(SimpleFunc.eapprox f n) ⁻¹' {i})

tactic: exact measurable_coe ((SimpleFunc.eapprox f n).measurableSet_preimage _)
state_before: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : α → ℝ≥0∞
hf : Measurable f
n : ℕ
i : ℝ≥0∞
x✝ : i ∈ (SimpleFunc.eapprox f n).range
⊢ Measurable fun μ => μ (↑(SimpleFunc.eapprox f n) ⁻¹' {i})
state_after: no goals
Theorem: Set.mulIndicator_union_of_not_mem_inter
File: Mathlib/Algebra/Group/Indicator.lean

tactic: rw [← mulIndicator_union_mul_inter_apply f s t, mulIndicator_of_not_mem h, mul_one]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s t : Set α
f✝ g : α → M
a : α
h : a ∉ s ∩ t
f : α → M
⊢ (s ∪ t).mulIndicator f a = s.mulIndicator f a * t.mulIndicator f a
state_after: no goals
Theorem: Equiv.exists_congr'
File: Mathlib/Logic/Equiv/Defs.lean

tactic: simp [h]
state_before: α : Sort u
β : Sort v
γ : Sort w
p : α → Prop
q : β → Prop
e : α ≃ β
h : ∀ (b : β), p (e.symm b) ↔ q b
⊢ (∃ b, p (e.symm b)) ↔ ∃ b, q b
state_after: no goals
Theorem: CategoryTheory.Quotient.natTrans_ext
File: Mathlib/CategoryTheory/Quotient.lean

tactic: ext1 ⟨X⟩
state_before: C : Type u_3
inst✝¹ : Category.{u_1, u_3} C
r : HomRel C
D : Type u_4
inst✝ : Category.{u_2, u_4} D
F✝ : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F✝.map f₁ = F✝.map f₂
F G : Quotient r ⥤ D
τ₁ τ₂ : F ⟶ G
h : whiskerLeft (functor r) τ₁ = whiskerLeft (functor r) τ₂
⊢ τ₁.app = τ₂.app
state_after: case h.mk
C : Type u_3
inst✝¹ : Category.{u_1, u_3} C
r : HomRel C
D : Type u_4
inst✝ : Category.{u_2, u_4} D
F✝ : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F✝.map f₁ = F✝.map f₂
F G : Quotient r ⥤ D
τ₁ τ₂ : F ⟶ G
h : whiskerLeft (functor r) τ₁ = whiskerLeft (functor r) τ₂
X : C
⊢ τ₁.app { as := X } = τ₂.app { as := X }

tactic: exact NatTrans.congr_app h X
state_before: case h.mk
C : Type u_3
inst✝¹ : Category.{u_1, u_3} C
r : HomRel C
D : Type u_4
inst✝ : Category.{u_2, u_4} D
F✝ : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F✝.map f₁ = F✝.map f₂
F G : Quotient r ⥤ D
τ₁ τ₂ : F ⟶ G
h : whiskerLeft (functor r) τ₁ = whiskerLeft (functor r) τ₂
X : C
⊢ τ₁.app { as := X } = τ₂.app { as := X }
state_after: no goals
Theorem: inv_smul_le_iff_of_pos
File: Mathlib/Algebra/Order/Module/Defs.lean

tactic: rw [← smul_le_smul_iff_of_pos_left ha, smul_inv_smul₀ ha.ne']
state_before: α : Type u_1
β : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β
inst✝⁵ : GroupWithZero α
inst✝⁴ : Preorder α
inst✝³ : Preorder β
inst✝² : MulAction α β
inst✝¹ : PosSMulMono α β
inst✝ : PosSMulReflectLE α β
ha : 0 < a
⊢ a⁻¹ • b₁ ≤ b₂ ↔ b₁ ≤ a • b₂
state_after: no goals
Theorem: Finset.compls_infs_eq_diffs
File: Mathlib/Data/Finset/Sups.lean

tactic: rw [infs_comm, infs_compls_eq_diffs]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : BooleanAlgebra α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Finset α
a b c : α
s t : Finset α
⊢ sᶜˢ ⊼ t = t \\ s
state_after: no goals
Theorem: CategoryTheory.BicartesianSq.of_has_biproduct₁
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: convert of_is_biproduct₁ (BinaryBiproduct.isBilimit X Y)
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproduct X Y
⊢ BicartesianSq biprod.fst biprod.snd 0 0
state_after: no goals
Theorem: tendsto_rpow_div_mul_add
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

tactic: refine
  Tendsto.congr' ?_
    ((tendsto_exp_nhds_zero_nhds_one.comp
          (by
            simpa only [mul_zero, pow_one] using
              (tendsto_const_nhds (x := a)).mul
                (tendsto_div_pow_mul_exp_add_atTop b c 1 hb))).comp
      tendsto_log_atTop)
state_before: a b c : ℝ
hb : 0 ≠ b
⊢ Tendsto (fun x => x ^ (a / (b * x + c))) atTop (𝓝 1)
state_after: a b c : ℝ
hb : 0 ≠ b
⊢ (rexp ∘ fun x => a * (x / (b * rexp x + c))) ∘ log =ᶠ[atTop] fun x => x ^ (a / (b * x + c))

tactic: apply eventuallyEq_of_mem (Ioi_mem_atTop (0 : ℝ))
state_before: a b c : ℝ
hb : 0 ≠ b
⊢ (rexp ∘ fun x => a * (x / (b * rexp x + c))) ∘ log =ᶠ[atTop] fun x => x ^ (a / (b * x + c))
state_after: a b c : ℝ
hb : 0 ≠ b
⊢ EqOn ((rexp ∘ fun x => a * (x / (b * rexp x + c))) ∘ log) (fun x => x ^ (a / (b * x + c))) (Set.Ioi 0)

tactic: intro x hx
state_before: a b c : ℝ
hb : 0 ≠ b
⊢ EqOn ((rexp ∘ fun x => a * (x / (b * rexp x + c))) ∘ log) (fun x => x ^ (a / (b * x + c))) (Set.Ioi 0)
state_after: a b c : ℝ
hb : 0 ≠ b
x : ℝ
hx : x ∈ Set.Ioi 0
⊢ ((rexp ∘ fun x => a * (x / (b * rexp x + c))) ∘ log) x = (fun x => x ^ (a / (b * x + c))) x

tactic: simp only [Set.mem_Ioi, Function.comp_apply] at hx ⊢
state_before: a b c : ℝ
hb : 0 ≠ b
x : ℝ
hx : x ∈ Set.Ioi 0
⊢ ((rexp ∘ fun x => a * (x / (b * rexp x + c))) ∘ log) x = (fun x => x ^ (a / (b * x + c))) x
state_after: a b c : ℝ
hb : 0 ≠ b
x : ℝ
hx : 0 < x
⊢ rexp (a * (log x / (b * rexp (log x) + c))) = x ^ (a / (b * x + c))

tactic: rw [exp_log hx, ← exp_log (rpow_pos_of_pos hx (a / (b * x + c))), log_rpow hx (a / (b * x + c))]
state_before: a b c : ℝ
hb : 0 ≠ b
x : ℝ
hx : 0 < x
⊢ rexp (a * (log x / (b * rexp (log x) + c))) = x ^ (a / (b * x + c))
state_after: a b c : ℝ
hb : 0 ≠ b
x : ℝ
hx : 0 < x
⊢ rexp (a * (log x / (b * x + c))) = rexp (a / (b * x + c) * log x)

tactic: field_simp
state_before: a b c : ℝ
hb : 0 ≠ b
x : ℝ
hx : 0 < x
⊢ rexp (a * (log x / (b * x + c))) = rexp (a / (b * x + c) * log x)
state_after: no goals

tactic: simpa only [mul_zero, pow_one] using
  (tendsto_const_nhds (x := a)).mul
    (tendsto_div_pow_mul_exp_add_atTop b c 1 hb)
state_before: a b c : ℝ
hb : 0 ≠ b
⊢ Tendsto ?m.17710 atTop (𝓝 0)
state_after: no goals
Theorem: ContDiffBump.measure_closedBall_le_integral
File: Mathlib/Analysis/Calculus/BumpFunction/Normed.lean

tactic: calc
(μ (closedBall c f.rIn)).toReal = ∫ x in closedBall c f.rIn, 1 ∂μ := by simp
_ = ∫ x in closedBall c f.rIn, f x ∂μ := setIntegral_congr measurableSet_closedBall
(fun x hx ↦ (one_of_mem_closedBall f hx).symm)
_ ≤ ∫ x, f x ∂μ := setIntegral_le_integral f.integrable (eventually_of_forall (fun x ↦ f.nonneg))
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : HasContDiffBump E
inst✝⁴ : MeasurableSpace E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
μ : Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : μ.IsOpenPosMeasure
⊢ (μ (closedBall c f.rIn)).toReal ≤ ∫ (x : E), ↑f x ∂μ
state_after: no goals

tactic: simp
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : HasContDiffBump E
inst✝⁴ : MeasurableSpace E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
μ : Measure E
inst✝³ : BorelSpace E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : IsLocallyFiniteMeasure μ
inst✝ : μ.IsOpenPosMeasure
⊢ (μ (closedBall c f.rIn)).toReal = ∫ (x : E) in closedBall c f.rIn, 1 ∂μ
state_after: no goals