1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Submodule.fg_iff_addSubmonoid_fg
File: Mathlib/RingTheory/Finiteness.lean

tactic: simpa [← span_nat_eq_addSubmonoid_closure] using hS
state_before: R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
P : Submodule ℕ M
x✝ : P.FG
S : Finset M
hS : span ℕ ↑S = P
⊢ AddSubmonoid.closure ↑S = P.toAddSubmonoid
state_after: no goals

tactic: simpa [← span_nat_eq_addSubmonoid_closure] using hS
state_before: R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
P : Submodule ℕ M
x✝ : P.FG
S : Finset M
hS : AddSubmonoid.closure ↑S = P.toAddSubmonoid
⊢ span ℕ ↑S = P
state_after: no goals
Theorem: Traversable.foldMap_map
File: Mathlib/Control/Fold.lean

tactic: simp only [foldMap, traverse_map, Function.comp]
state_before: α β γ : Type u
t : Type u → Type u
inst✝² : Traversable t
inst✝¹ : LawfulTraversable t
inst✝ : Monoid γ
f : α → β
g : β → γ
xs : t α
⊢ foldMap g (f <$> xs) = foldMap (g ∘ f) xs
state_after: no goals
Theorem: Pell.IsFundamental.y_le_y
File: Mathlib/NumberTheory/Pell.lean

tactic: have H : d * (a₁.y ^ 2 - a.y ^ 2) = a₁.x ^ 2 - a.x ^ 2 := by rw [a.prop_x, a₁.prop_x]; ring
state_before: d : ℤ
a₁ : Solution₁ d
h : IsFundamental a₁
a : Solution₁ d
hax : 1 < a.x
hay : 0 < a.y
⊢ a₁.y ≤ a.y
state_after: d : ℤ
a₁ : Solution₁ d
h : IsFundamental a₁
a : Solution₁ d
hax : 1 < a.x
hay : 0 < a.y
H : d * (a₁.y ^ 2 - a.y ^ 2) = a₁.x ^ 2 - a.x ^ 2
⊢ a₁.y ≤ a.y

tactic: rw [← abs_of_pos hay, ← abs_of_pos h.2.1, ← sq_le_sq, ← mul_le_mul_left h.d_pos, ← sub_nonpos, ←
  mul_sub, H, sub_nonpos, sq_le_sq, abs_of_pos (zero_lt_one.trans h.1),
  abs_of_pos (zero_lt_one.trans hax)]
state_before: d : ℤ
a₁ : Solution₁ d
h : IsFundamental a₁
a : Solution₁ d
hax : 1 < a.x
hay : 0 < a.y
H : d * (a₁.y ^ 2 - a.y ^ 2) = a₁.x ^ 2 - a.x ^ 2
⊢ a₁.y ≤ a.y
state_after: d : ℤ
a₁ : Solution₁ d
h : IsFundamental a₁
a : Solution₁ d
hax : 1 < a.x
hay : 0 < a.y
H : d * (a₁.y ^ 2 - a.y ^ 2) = a₁.x ^ 2 - a.x ^ 2
⊢ a₁.x ≤ a.x

tactic: exact h.x_le_x hax
state_before: d : ℤ
a₁ : Solution₁ d
h : IsFundamental a₁
a : Solution₁ d
hax : 1 < a.x
hay : 0 < a.y
H : d * (a₁.y ^ 2 - a.y ^ 2) = a₁.x ^ 2 - a.x ^ 2
⊢ a₁.x ≤ a.x
state_after: no goals

tactic: rw [a.prop_x, a₁.prop_x]
state_before: d : ℤ
a₁ : Solution₁ d
h : IsFundamental a₁
a : Solution₁ d
hax : 1 < a.x
hay : 0 < a.y
⊢ d * (a₁.y ^ 2 - a.y ^ 2) = a₁.x ^ 2 - a.x ^ 2
state_after: d : ℤ
a₁ : Solution₁ d
h : IsFundamental a₁
a : Solution₁ d
hax : 1 < a.x
hay : 0 < a.y
⊢ d * (a₁.y ^ 2 - a.y ^ 2) = 1 + d * a₁.y ^ 2 - (1 + d * a.y ^ 2)

tactic: ring
state_before: d : ℤ
a₁ : Solution₁ d
h : IsFundamental a₁
a : Solution₁ d
hax : 1 < a.x
hay : 0 < a.y
⊢ d * (a₁.y ^ 2 - a.y ^ 2) = 1 + d * a₁.y ^ 2 - (1 + d * a.y ^ 2)
state_after: no goals
Theorem: Complex.tanh_neg
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [tanh, neg_div]
state_before: x y : ℂ
⊢ tanh (-x) = -tanh x
state_after: no goals
Theorem: conjugate_lt_conjugate'
File: Mathlib/Algebra/Star/Order.lean

tactic: simpa only [star_star] using conjugate_lt_conjugate hab hc.star
state_before: R : Type u
inst✝³ : NonUnitalSemiring R
inst✝² : PartialOrder R
inst✝¹ : StarRing R
inst✝ : StarOrderedRing R
a b : R
hab : a < b
c : R
hc : IsRegular c
⊢ c * a * star c < c * b * star c
state_after: no goals
Theorem: Module.Flat.iff_lTensor_injective'
File: Mathlib/RingTheory/Flat/Basic.lean

tactic: simpa [← comm_comp_rTensor_comp_comm_eq] using Module.Flat.iff_rTensor_injective' R M
state_before: R : Type u
M : Type v
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
⊢ Flat R M ↔ ∀ (I : Ideal R), Function.Injective ⇑(lTensor M (Submodule.subtype I))
state_after: no goals
Theorem: Int.lcm_mul_right
File: Mathlib/Data/Int/GCD.lean

tactic: simp_rw [Int.lcm, natAbs_mul, Nat.lcm_mul_right]
state_before: m n k : ℤ
⊢ (m * n).lcm (k * n) = m.lcm k * n.natAbs
state_after: no goals
Theorem: Bool.coe_sort_false
File: Mathlib/Init/Data/Bool/Lemmas.lean

tactic: simp
state_before: ⊢ (false = true) = False
state_after: no goals
Theorem: Filter.limsSup_principal
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp only [limsSup, eventually_principal]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : ConditionallyCompleteLattice α
s : Set α
h : BddAbove s
hs : s.Nonempty
⊢ (𝓟 s).limsSup = sSup s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : ConditionallyCompleteLattice α
s : Set α
h : BddAbove s
hs : s.Nonempty
⊢ sInf {a | ∀ x ∈ s, x ≤ a} = sSup s

tactic: exact csInf_upper_bounds_eq_csSup h hs
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : ConditionallyCompleteLattice α
s : Set α
h : BddAbove s
hs : s.Nonempty
⊢ sInf {a | ∀ x ∈ s, x ≤ a} = sSup s
state_after: no goals
Theorem: NonUnitalSubalgebra.toNonUnitalSubring_injective
File: Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean

tactic: rw [← mem_toNonUnitalSubring, ← mem_toNonUnitalSubring, h]
state_before: F : Type v'
R' : Type u'
R : Type u
A : Type v
B : Type w
C : Type w'
inst✝⁶ : CommRing R
inst✝⁵ : NonUnitalNonAssocRing A
inst✝⁴ : NonUnitalNonAssocRing B
inst✝³ : NonUnitalNonAssocRing C
inst✝² : Module R A
inst✝¹ : Module R B
inst✝ : Module R C
S T : NonUnitalSubalgebra R A
h : S.toNonUnitalSubring = T.toNonUnitalSubring
x : A
⊢ x ∈ S ↔ x ∈ T
state_after: no goals
Theorem: Nat.Ico_succ_left
File: Mathlib/Order/Interval/Finset/Nat.lean

tactic: ext x
state_before: a b c : ℕ
⊢ Ico a.succ b = Ioo a b
state_after: case a
a b c x : ℕ
⊢ x ∈ Ico a.succ b ↔ x ∈ Ioo a b

tactic: rw [mem_Ico, mem_Ioo, succ_le_iff]
state_before: case a
a b c x : ℕ
⊢ x ∈ Ico a.succ b ↔ x ∈ Ioo a b
state_after: no goals
Theorem: NoZeroSMulDivisors.algebraMap_injective
File: Mathlib/Algebra/Algebra/Basic.lean

tactic: simpa only [algebraMap_eq_smul_one'] using smul_left_injective R one_ne_zero
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Nontrivial A
inst✝¹ : Algebra R A
inst✝ : NoZeroSMulDivisors R A
⊢ Function.Injective ⇑(algebraMap R A)
state_after: no goals
Theorem: CategoryTheory.Equivalence.unitInv_app_inverse
File: Mathlib/CategoryTheory/Equivalence.lean

tactic: symm
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
Y : D
⊢ e.unitInv.app (e.inverse.obj Y) = e.inverse.map (e.counit.app Y)
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
Y : D
⊢ e.inverse.map (e.counit.app Y) = e.unitInv.app (e.inverse.obj Y)

tactic: erw [← Iso.hom_comp_eq_id (e.unitIso.app _), unit_inverse_comp]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
Y : D
⊢ e.inverse.map (e.counit.app Y) = e.unitInv.app (e.inverse.obj Y)
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
Y : D
⊢ 𝟙 (e.inverse.obj Y) = 𝟙 ((𝟭 C).obj (e.inverse.obj Y))

tactic: rfl
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
Y : D
⊢ 𝟙 (e.inverse.obj Y) = 𝟙 ((𝟭 C).obj (e.inverse.obj Y))
state_after: no goals
Theorem: Polynomial.Separable.eval₂_derivative_ne_zero
File: Mathlib/FieldTheory/Separable.lean

tactic: intro hx'
state_before: R : Type u
inst✝² : CommSemiring R
S : Type v
inst✝¹ : CommSemiring S
inst✝ : Nontrivial S
f : R →+* S
p : R[X]
h : p.Separable
x : S
hx : eval₂ f x p = 0
⊢ eval₂ f x (derivative p) ≠ 0
state_after: R : Type u
inst✝² : CommSemiring R
S : Type v
inst✝¹ : CommSemiring S
inst✝ : Nontrivial S
f : R →+* S
p : R[X]
h : p.Separable
x : S
hx : eval₂ f x p = 0
hx' : eval₂ f x (derivative p) = 0
⊢ False

tactic: obtain ⟨a, b, e⟩ := h
state_before: R : Type u
inst✝² : CommSemiring R
S : Type v
inst✝¹ : CommSemiring S
inst✝ : Nontrivial S
f : R →+* S
p : R[X]
h : p.Separable
x : S
hx : eval₂ f x p = 0
hx' : eval₂ f x (derivative p) = 0
⊢ False
state_after: case intro.intro
R : Type u
inst✝² : CommSemiring R
S : Type v
inst✝¹ : CommSemiring S
inst✝ : Nontrivial S
f : R →+* S
p : R[X]
x : S
hx : eval₂ f x p = 0
hx' : eval₂ f x (derivative p) = 0
a b : R[X]
e : a * p + b * derivative p = 1
⊢ False

tactic: apply_fun Polynomial.eval₂ f x at e
state_before: case intro.intro
R : Type u
inst✝² : CommSemiring R
S : Type v
inst✝¹ : CommSemiring S
inst✝ : Nontrivial S
f : R →+* S
p : R[X]
x : S
hx : eval₂ f x p = 0
hx' : eval₂ f x (derivative p) = 0
a b : R[X]
e : a * p + b * derivative p = 1
⊢ False
state_after: case intro.intro
R : Type u
inst✝² : CommSemiring R
S : Type v
inst✝¹ : CommSemiring S
inst✝ : Nontrivial S
f : R →+* S
p : R[X]
x : S
hx : eval₂ f x p = 0
hx' : eval₂ f x (derivative p) = 0
a b : R[X]
e : eval₂ f x (a * p + b * derivative p) = eval₂ f x 1
⊢ False

tactic: simp only [eval₂_add, eval₂_mul, hx, mul_zero, hx', add_zero, eval₂_one, zero_ne_one] at e
state_before: case intro.intro
R : Type u
inst✝² : CommSemiring R
S : Type v
inst✝¹ : CommSemiring S
inst✝ : Nontrivial S
f : R →+* S
p : R[X]
x : S
hx : eval₂ f x p = 0
hx' : eval₂ f x (derivative p) = 0
a b : R[X]
e : eval₂ f x (a * p + b * derivative p) = eval₂ f x 1
⊢ False
state_after: no goals
Theorem: Multiset.erase_add_left_neg
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [add_comm, erase_add_right_neg s h, add_comm]
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ t✝ : Multiset α
a✝ b a : α
s t : Multiset α
h : a ∉ t
⊢ (s + t).erase a = s.erase a + t
state_after: no goals
Theorem: NonUnitalSubring.coe_iSup_of_directed
File: Mathlib/RingTheory/NonUnitalSubring/Basic.lean

tactic: simp [mem_iSup_of_directed hS]
state_before: F : Type w
R : Type u
S✝ : Type v
T : Type u_1
inst✝⁵ : NonUnitalNonAssocRing R
inst✝⁴ : NonUnitalNonAssocRing S✝
inst✝³ : NonUnitalNonAssocRing T
inst✝² : FunLike F R S✝
inst✝¹ : NonUnitalRingHomClass F R S✝
g : S✝ →ₙ+* T
f : R →ₙ+* S✝
ι : Sort u_2
inst✝ : Nonempty ι
S : ι → NonUnitalSubring R
hS : Directed (fun x x_1 => x ≤ x_1) S
x : R
⊢ x ∈ ↑(⨆ i, S i) ↔ x ∈ ⋃ i, ↑(S i)
state_after: no goals
Theorem: CategoryTheory.CosimplicialObject.δ_comp_δ_self
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: dsimp [δ]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
⊢ X.δ i ≫ X.δ i.castSucc = X.δ i ≫ X.δ i.succ
state_after: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
⊢ X.map (SimplexCategory.δ i) ≫ X.map (SimplexCategory.δ i.castSucc) =
    X.map (SimplexCategory.δ i) ≫ X.map (SimplexCategory.δ i.succ)

tactic: simp only [← X.map_comp, SimplexCategory.δ_comp_δ_self]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
⊢ X.map (SimplexCategory.δ i) ≫ X.map (SimplexCategory.δ i.castSucc) =
    X.map (SimplexCategory.δ i) ≫ X.map (SimplexCategory.δ i.succ)
state_after: no goals
Theorem: GaussianFourier.integral_cexp_neg_mul_sq_norm
File: Mathlib/Analysis/SpecialFunctions/Gaussian/FourierTransform.lean

tactic: simpa using integral_cexp_neg_mul_sq_norm_add hb 0 (0 : V)
state_before: b : ℂ
V : Type u_1
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : FiniteDimensional ℝ V
inst✝¹ : MeasurableSpace V
inst✝ : BorelSpace V
hb : 0 < b.re
⊢ ∫ (v : V), cexp (-b * ↑‖v‖ ^ 2) = (↑π / b) ^ (↑(FiniteDimensional.finrank ℝ V) / 2)
state_after: no goals
Theorem: Inducing.isCompact_iff
File: Mathlib/Topology/Compactness/Compact.lean

tactic: refine ⟨fun hs => hs.image hf.continuous, fun hs F F_ne_bot F_le => ?_⟩
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
f : X → Y
hf : Inducing f
⊢ IsCompact s ↔ IsCompact (f '' s)
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
f : X → Y
hf : Inducing f
hs : IsCompact (f '' s)
F : Filter X
F_ne_bot : F.NeBot
F_le : F ≤ 𝓟 s
⊢ ∃ x ∈ s, ClusterPt x F

tactic: obtain ⟨_, ⟨x, x_in : x ∈ s, rfl⟩, hx : ClusterPt (f x) (map f F)⟩ :=
  hs ((map_mono F_le).trans_eq map_principal)
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
f : X → Y
hf : Inducing f
hs : IsCompact (f '' s)
F : Filter X
F_ne_bot : F.NeBot
F_le : F ≤ 𝓟 s
⊢ ∃ x ∈ s, ClusterPt x F
state_after: case intro.intro.intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
f : X → Y
hf : Inducing f
hs : IsCompact (f '' s)
F : Filter X
F_ne_bot : F.NeBot
F_le : F ≤ 𝓟 s
x : X
x_in : x ∈ s
hx : ClusterPt (f x) (map f F)
⊢ ∃ x ∈ s, ClusterPt x F

tactic: exact ⟨x, x_in, hf.mapClusterPt_iff.1 hx⟩
state_before: case intro.intro.intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
f : X → Y
hf : Inducing f
hs : IsCompact (f '' s)
F : Filter X
F_ne_bot : F.NeBot
F_le : F ≤ 𝓟 s
x : X
x_in : x ∈ s
hx : ClusterPt (f x) (map f F)
⊢ ∃ x ∈ s, ClusterPt x F
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.map_dblU
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: simp [dblU, map_polynomialX, ← eval₂_id, eval₂_comp_left]
state_before: R : Type u
inst✝² : CommRing R
W' : Jacobian R
F : Type v
inst✝¹ : Field F
W : Jacobian F
S : Type u_1
inst✝ : CommRing S
f : R →+* S
P Q : Fin 3 → R
⊢ dblU (map W' f) (⇑f ∘ P) = f (W'.dblU P)
state_after: no goals
Theorem: SimpleGraph.infinite_iff_in_eventualRange
File: Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean

tactic: simp only [C.infinite_iff_in_all_ranges, CategoryTheory.Functor.eventualRange, Set.mem_iInter,
  Set.mem_range, componentComplFunctor_map]
state_before: V : Type u
G : SimpleGraph V
K✝ L L' M : Set V
K : (Finset V)ᵒᵖ
C : G.componentComplFunctor.obj K
⊢ (ComponentCompl.supp C).Infinite ↔ C ∈ G.componentComplFunctor.eventualRange K
state_after: V : Type u
G : SimpleGraph V
K✝ L L' M : Set V
K : (Finset V)ᵒᵖ
C : G.componentComplFunctor.obj K
⊢ (∀ (L : Finset V) (h : K.unop ⊆ L), ∃ D, ComponentCompl.hom h D = C) ↔
    ∀ (i : (Finset V)ᵒᵖ) (i_1 : i ⟶ K), ∃ y, ComponentCompl.hom ⋯ y = C

tactic: exact
  ⟨fun h Lop KL => h Lop.unop (le_of_op_hom KL), fun h L KL =>
    h (Opposite.op L) (opHomOfLE KL)⟩
state_before: V : Type u
G : SimpleGraph V
K✝ L L' M : Set V
K : (Finset V)ᵒᵖ
C : G.componentComplFunctor.obj K
⊢ (∀ (L : Finset V) (h : K.unop ⊆ L), ∃ D, ComponentCompl.hom h D = C) ↔
    ∀ (i : (Finset V)ᵒᵖ) (i_1 : i ⟶ K), ∃ y, ComponentCompl.hom ⋯ y = C
state_after: no goals
Theorem: gradient_const
File: Mathlib/Analysis/Calculus/Gradient/Basic.lean

tactic: rw [gradient, fderiv_const, Pi.zero_apply, map_zero]
state_before: 𝕜 : Type u_1
F : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 F
inst✝ : CompleteSpace F
f : F → 𝕜
f' x : F
s : Set F
L : Filter F
c : 𝕜
⊢ ∇ (fun x => c) x = 0
state_after: no goals
Theorem: Multiset.singleton_bind
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp [bind]
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f g : α → Multiset β
⊢ {a}.bind f = f a
state_after: no goals
Theorem: MeasureTheory.Content.outerMeasure_preimage
File: Mathlib/MeasureTheory/Measure/Content.lean

tactic: refine inducedOuterMeasure_preimage _ μ.innerContent_iUnion_nat μ.innerContent_mono _
  (fun _ => f.isOpen_preimage) ?_
state_before: G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : R1Space G
f : G ≃ₜ G
h : ∀ ⦃K : Compacts G⦄, (fun s => ↑(μ.toFun s)) (Compacts.map ⇑f ⋯ K) = (fun s => ↑(μ.toFun s)) K
A : Set G
⊢ μ.outerMeasure (⇑f ⁻¹' A) = μ.outerMeasure A
state_after: G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : R1Space G
f : G ≃ₜ G
h : ∀ ⦃K : Compacts G⦄, (fun s => ↑(μ.toFun s)) (Compacts.map ⇑f ⋯ K) = (fun s => ↑(μ.toFun s)) K
A : Set G
⊢ ∀ (s : Set G) (hs : IsOpen s),
    μ.innerContent { carrier := ⇑f.toEquiv ⁻¹' s, is_open' := ⋯ } = μ.innerContent { carrier := s, is_open' := hs }

tactic: intro s hs
state_before: G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : R1Space G
f : G ≃ₜ G
h : ∀ ⦃K : Compacts G⦄, (fun s => ↑(μ.toFun s)) (Compacts.map ⇑f ⋯ K) = (fun s => ↑(μ.toFun s)) K
A : Set G
⊢ ∀ (s : Set G) (hs : IsOpen s),
    μ.innerContent { carrier := ⇑f.toEquiv ⁻¹' s, is_open' := ⋯ } = μ.innerContent { carrier := s, is_open' := hs }
state_after: G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : R1Space G
f : G ≃ₜ G
h : ∀ ⦃K : Compacts G⦄, (fun s => ↑(μ.toFun s)) (Compacts.map ⇑f ⋯ K) = (fun s => ↑(μ.toFun s)) K
A s : Set G
hs : IsOpen s
⊢ μ.innerContent { carrier := ⇑f.toEquiv ⁻¹' s, is_open' := ⋯ } = μ.innerContent { carrier := s, is_open' := hs }

tactic: convert μ.innerContent_comap f h ⟨s, hs⟩
state_before: G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : R1Space G
f : G ≃ₜ G
h : ∀ ⦃K : Compacts G⦄, (fun s => ↑(μ.toFun s)) (Compacts.map ⇑f ⋯ K) = (fun s => ↑(μ.toFun s)) K
A s : Set G
hs : IsOpen s
⊢ μ.innerContent { carrier := ⇑f.toEquiv ⁻¹' s, is_open' := ⋯ } = μ.innerContent { carrier := s, is_open' := hs }
state_after: no goals
Theorem: EReal.mul_inv
File: Mathlib/Data/Real/EReal.lean

tactic: induction a, b using EReal.induction₂_symm with
| top_top | top_zero | top_bot | zero_bot | bot_bot => simp
| @symm a b h => rw [mul_comm b a, mul_comm b⁻¹ a⁻¹]; exact h
| top_pos x x_pos => rw [top_mul_of_pos (EReal.coe_pos.2 x_pos), inv_top, zero_mul]
| top_neg x x_neg => rw [top_mul_of_neg (EReal.coe_neg'.2 x_neg), inv_bot, inv_top, zero_mul]
| pos_bot x x_pos => rw [mul_bot_of_pos (EReal.coe_pos.2 x_pos), inv_bot, mul_zero]
| coe_coe x y => rw [← coe_mul, ← coe_inv, _root_.mul_inv, coe_mul, coe_inv, coe_inv]
| neg_bot x x_neg => rw [mul_bot_of_neg (EReal.coe_neg'.2 x_neg), inv_top, inv_bot, mul_zero]
state_before: a b : EReal
⊢ (a * b)⁻¹ = a⁻¹ * b⁻¹
state_after: no goals

tactic: simp
state_before: case bot_bot

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

tactic: rw [mul_comm b a, mul_comm b⁻¹ a⁻¹]
state_before: case symm
a b : EReal
h : (a * b)⁻¹ = a⁻¹ * b⁻¹
⊢ (b * a)⁻¹ = b⁻¹ * a⁻¹
state_after: case symm
a b : EReal
h : (a * b)⁻¹ = a⁻¹ * b⁻¹
⊢ (a * b)⁻¹ = a⁻¹ * b⁻¹

tactic: exact h
state_before: case symm
a b : EReal
h : (a * b)⁻¹ = a⁻¹ * b⁻¹
⊢ (a * b)⁻¹ = a⁻¹ * b⁻¹
state_after: no goals

tactic: rw [top_mul_of_pos (EReal.coe_pos.2 x_pos), inv_top, zero_mul]
state_before: case top_pos
x : ℝ
x_pos : 0 < x
⊢ (⊤ * ↑x)⁻¹ = ⊤⁻¹ * (↑x)⁻¹
state_after: no goals

tactic: rw [top_mul_of_neg (EReal.coe_neg'.2 x_neg), inv_bot, inv_top, zero_mul]
state_before: case top_neg
x : ℝ
x_neg : x < 0
⊢ (⊤ * ↑x)⁻¹ = ⊤⁻¹ * (↑x)⁻¹
state_after: no goals

tactic: rw [mul_bot_of_pos (EReal.coe_pos.2 x_pos), inv_bot, mul_zero]
state_before: case pos_bot
x : ℝ
x_pos : 0 < x
⊢ (↑x * ⊥)⁻¹ = (↑x)⁻¹ * ⊥⁻¹
state_after: no goals

tactic: rw [← coe_mul, ← coe_inv, _root_.mul_inv, coe_mul, coe_inv, coe_inv]
state_before: case coe_coe
x y : ℝ
⊢ (↑x * ↑y)⁻¹ = (↑x)⁻¹ * (↑y)⁻¹
state_after: no goals

tactic: rw [mul_bot_of_neg (EReal.coe_neg'.2 x_neg), inv_top, inv_bot, mul_zero]
state_before: case neg_bot
x : ℝ
x_neg : x < 0
⊢ (↑x * ⊥)⁻¹ = (↑x)⁻¹ * ⊥⁻¹
state_after: no goals
Theorem: sub_div'
File: Mathlib/Algebra/Field/Basic.lean

tactic: simpa using div_sub_div b a one_ne_zero hc
state_before: α : Type u_1
β : Type u_2
K : Type u_3
inst✝ : Field K
a b c : K
hc : c ≠ 0
⊢ b - a / c = (b * c - a) / c
state_after: no goals
Theorem: singleton_mul_closedBall
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: simp_rw [singleton_mul, ← smul_eq_mul, image_smul, smul_closedBall]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ {x} * closedBall y δ = closedBall (x * y) δ
state_after: no goals
Theorem: Polynomial.natDegree_mem_support_of_nonzero
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: rw [mem_support_iff]
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
H : p ≠ 0
⊢ p.natDegree ∈ p.support
state_after: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
H : p ≠ 0
⊢ p.coeff p.natDegree ≠ 0

tactic: exact (not_congr leadingCoeff_eq_zero).mpr H
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
H : p ≠ 0
⊢ p.coeff p.natDegree ≠ 0
state_after: no goals
Theorem: Nat.decreasingInduction_succ
File: Mathlib/Data/Nat/Defs.lean

tactic: dsimp only [decreasingInduction]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
P : ℕ → Sort u_1
h : (n : ℕ) → P (n + 1) → P n
mn : m ≤ n
msn : m ≤ n + 1
hP : P (n + 1)
⊢ decreasingInduction h msn hP = decreasingInduction h mn (h n hP)
state_after: a b c d m n k : ℕ
p q : ℕ → Prop
P : ℕ → Sort u_1
h : (n : ℕ) → P (n + 1) → P n
mn : m ≤ n
msn : m ≤ n + 1
hP : P (n + 1)
⊢ leRecOn msn (fun {k} ih hsk => ih (h k hsk)) (fun h => h) hP =
    leRecOn mn (fun {k} ih hsk => ih (h k hsk)) (fun h => h) (h n hP)

tactic: rw [leRecOn_succ]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
P : ℕ → Sort u_1
h : (n : ℕ) → P (n + 1) → P n
mn : m ≤ n
msn : m ≤ n + 1
hP : P (n + 1)
⊢ leRecOn msn (fun {k} ih hsk => ih (h k hsk)) (fun h => h) hP =
    leRecOn mn (fun {k} ih hsk => ih (h k hsk)) (fun h => h) (h n hP)
state_after: no goals
Theorem: nonZeroDivisors.associated_coe
File: Mathlib/Algebra/GroupWithZero/NonZeroDivisors.lean

tactic: simp [Associated]
state_before: M₀ : Type u_1
inst✝¹ inst✝ : MonoidWithZero M₀
a b : ↥M₀⁰
⊢ (∃ b_1, ↑a * ↑(unitsNonZeroDivisorsEquiv.symm.symm b_1) = ↑b) ↔ Associated a b
state_after: M₀ : Type u_1
inst✝¹ inst✝ : MonoidWithZero M₀
a b : ↥M₀⁰
⊢ (∃ b_1, ↑a * ↑↑b_1 = ↑b) ↔ ∃ u, a * ↑u = b

tactic: norm_cast
state_before: M₀ : Type u_1
inst✝¹ inst✝ : MonoidWithZero M₀
a b : ↥M₀⁰
⊢ (∃ b_1, ↑a * ↑↑b_1 = ↑b) ↔ ∃ u, a * ↑u = b
state_after: no goals
Theorem: schnirelmannDensity_nonneg
File: Mathlib/Combinatorics/Schnirelmann.lean

tactic: positivity
state_before: A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
x✝ : { n // 0 < n }
⊢ 0 ≤ ↑(filter (fun x => x ∈ A) (Ioc 0 ↑x✝)).card / ↑↑x✝
state_after: no goals
Theorem: EMetric.uniformInducing_iff
File: Mathlib/Topology/EMetricSpace/Basic.lean

tactic: simp only [subset_def, Prod.forall]
state_before: α : Type u
β : Type v
X : Type u_1
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
f : α → β
⊢ (∀ (i' : ℝ≥0∞), 0 < i' → ∃ i, 0 < i ∧ Prod.map f f ⁻¹' {p | edist p.1 p.2 < i} ⊆ {p | edist p.1 p.2 < i'}) ↔
    ∀ δ > 0, ∃ ε > 0, ∀ {a b : α}, edist (f a) (f b) < ε → edist a b < δ
state_after: α : Type u
β : Type v
X : Type u_1
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
f : α → β
⊢ (∀ (i' : ℝ≥0∞),
      0 < i' →
        ∃ i,
          0 < i ∧ ∀ (a b : α), (a, b) ∈ Prod.map f f ⁻¹' {p | edist p.1 p.2 < i} → (a, b) ∈ {p | edist p.1 p.2 < i'}) ↔
    ∀ δ > 0, ∃ ε > 0, ∀ {a b : α}, edist (f a) (f b) < ε → edist a b < δ

tactic: rfl
state_before: α : Type u
β : Type v
X : Type u_1
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
f : α → β
⊢ (∀ (i' : ℝ≥0∞),
      0 < i' →
        ∃ i,
          0 < i ∧ ∀ (a b : α), (a, b) ∈ Prod.map f f ⁻¹' {p | edist p.1 p.2 < i} → (a, b) ∈ {p | edist p.1 p.2 < i'}) ↔
    ∀ δ > 0, ∃ ε > 0, ∀ {a b : α}, edist (f a) (f b) < ε → edist a b < δ
state_after: no goals
Theorem: MeasureTheory.MeasurePreserving.lintegral_comp_emb
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [← hg.map_eq, hge.lintegral_map]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν✝ : Measure α
mb : MeasurableSpace β
ν : Measure β
g : α → β
hg : MeasurePreserving g μ ν
hge : MeasurableEmbedding g
f : β → ℝ≥0∞
⊢ ∫⁻ (a : α), f (g a) ∂μ = ∫⁻ (b : β), f b ∂ν
state_after: no goals
Theorem: Submodule.lTensorOne'_one_tmul
File: Mathlib/LinearAlgebra/TensorProduct/Submodule.lean

tactic: simpa using lTensorOne'_tmul 1 n
state_before: R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
n : ↥N
⊢ N.lTensorOne' (1 ⊗ₜ[R] n) = n
state_after: no goals
Theorem: Finset.univ_map_subtype
File: Mathlib/Data/Fintype/Basic.lean

tactic: rw [← subtype_map, subtype_univ]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : Fintype α
s t : Finset α
inst✝² : Fintype α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : Fintype { a // p a }
⊢ map (Embedding.subtype p) univ = filter p univ
state_after: no goals