tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.snorm'_neg
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: simp [snorm']
state_before: α : Type u_1
E : Type ?u.3175531
F : Type u_2
G : Type ?u.3175537
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
⊢ snorm' (-f) q μ = snorm' f q μ
Theorem: Complex.frontier_setOf_le_re
File: Mathlib/Analysis/Complex/ReImTopology.lean

tactic: simpa only [frontier_Ici] using frontier_preimage_re (Ici a)
state_before: a : ℝ
⊢ frontier {z | a ≤ z.re} = {z | z.re = a}
Theorem: Std.PairingHeapImp.Heap.size_merge_node
File: Std/Data/PairingHeap.lean

tactic: unfold merge
state_before: α : Type u_1
le : α → α → Bool
a₁ : α
c₁ s₁ : Heap α
a₂ : α
c₂ s₂ : Heap α
⊢ size (merge le (node a₁ c₁ s₁) (node a₂ c₂ s₂)) = size c₁ + size c₂ + 2

tactic: dsimp
state_before: α : Type u_1
le : α → α → Bool
a₁ : α
c₁ s₁ : Heap α
a₂ : α
c₂ s₂ : Heap α
⊢ size
      (match node a₁ c₁ s₁, node a₂ c₂ s₂ with
      | nil, nil => nil
      | nil, node a₂ c₂ sibling => node a₂ c₂ nil
      | node a₁ c₁ sibling, nil => node a₁ c₁ nil
      | node a₁ c₁ sibling, node a₂ c₂ sibling_1 =>
        if le a₁ a₂ = true then node a₁ (node a₂ c₂ c₁) nil else node a₂ (node a₁ c₁ c₂) nil) =
    size c₁ + size c₂ + 2

tactic: split <;> simp_arith [size]
state_before: α : Type u_1
le : α → α → Bool
a₁ : α
c₁ s₁ : Heap α
a₂ : α
c₂ s₂ : Heap α
⊢ size (if le a₁ a₂ = true then node a₁ (node a₂ c₂ c₁) nil else node a₂ (node a₁ c₁ c₂) nil) = size c₁ + size c₂ + 2
Theorem: Mathlib.Tactic.Ring.div_pf
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R✝ : Type ?u.392217
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝¹ : CommSemiring R✝
R : Type u_1
inst✝ : DivisionRing R
a b c d : R
x✝¹ : b⁻¹ = c
x✝ : a * c = d
⊢ a / b = d

tactic: simp [div_eq_mul_inv]
state_before: u : Lean.Level
R✝ : Type ?u.392217
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝¹ : CommSemiring R✝
R : Type u_1
inst✝ : DivisionRing R
a b : R
⊢ a / b = a * b⁻¹
Theorem: nnnorm_zpow_le_mul_norm
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simpa only [← NNReal.coe_le_coe, NNReal.coe_mul] using norm_zpow_le_mul_norm n a
state_before: 𝓕 : Type ?u.1160174
𝕜 : Type ?u.1160177
α : Type u_1
ι : Type ?u.1160183
κ : Type ?u.1160186
E : Type ?u.1160189
F : Type ?u.1160192
G : Type ?u.1160195
inst✝² : SeminormedCommGroup E
inst✝¹ : SeminormedCommGroup F
a✝ a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : SeminormedCommGroup α
n : ℤ
a : α
⊢ ‖a ^ n‖₊ ≤ ‖n‖₊ * ‖a‖₊
Theorem: Polynomial.Monic.eq_one_of_map_eq_one
File: Mathlib/Data/Polynomial/Monic.lean

tactic: nontriviality R
state_before: R : Type u
S✝ : Type v
a b : R
m n : ℕ
ι : Type y
inst✝² : Semiring R
p q r : R[X]
S : Type u_1
inst✝¹ : Semiring S
inst✝ : Nontrivial S
f : R →+* S
hp : Monic p
map_eq : Polynomial.map f p = 1
⊢ p = 1

tactic: have hndeg : p.natDegree = 0 :=
  WithBot.coe_eq_coe.mp ((degree_eq_natDegree hp.ne_zero).symm.trans hdeg)
state_before: R : Type u
S✝ : Type v
a b : R
m n : ℕ
ι : Type y
inst✝² : Semiring R
p q r : R[X]
S : Type u_1
inst✝¹ : Semiring S
inst✝ : Nontrivial S
f : R →+* S
hp : Monic p
map_eq : Polynomial.map f p = 1
✝ : Nontrivial R
hdeg : degree p = 0
⊢ p = 1

tactic: convert eq_C_of_degree_eq_zero hdeg
state_before: R : Type u
S✝ : Type v
a b : R
m n : ℕ
ι : Type y
inst✝² : Semiring R
p q r : R[X]
S : Type u_1
inst✝¹ : Semiring S
inst✝ : Nontrivial S
f : R →+* S
hp : Monic p
map_eq : Polynomial.map f p = 1
✝ : Nontrivial R
hdeg : degree p = 0
hndeg : natDegree p = 0
⊢ p = 1

tactic: rw [← hndeg, ← Polynomial.leadingCoeff, hp.leadingCoeff, C.map_one]
state_before: case h.e'_3
R : Type u
S✝ : Type v
a b : R
m n : ℕ
ι : Type y
inst✝² : Semiring R
p q r : R[X]
S : Type u_1
inst✝¹ : Semiring S
inst✝ : Nontrivial S
f : R →+* S
hp : Monic p
map_eq : Polynomial.map f p = 1
✝ : Nontrivial R
hdeg : degree p = 0
hndeg : natDegree p = 0
⊢ 1 = ↑C (coeff p 0)

tactic: rw [← degree_map_eq_of_leadingCoeff_ne_zero f _, map_eq, degree_one]
state_before: R : Type u
S✝ : Type v
a b : R
m n : ℕ
ι : Type y
inst✝² : Semiring R
p q r : R[X]
S : Type u_1
inst✝¹ : Semiring S
inst✝ : Nontrivial S
f : R →+* S
hp : Monic p
map_eq : Polynomial.map f p = 1
✝ : Nontrivial R
⊢ degree p = 0

tactic: rw [hp.leadingCoeff, f.map_one]
state_before: R : Type u
S✝ : Type v
a b : R
m n : ℕ
ι : Type y
inst✝² : Semiring R
p q r : R[X]
S : Type u_1
inst✝¹ : Semiring S
inst✝ : Nontrivial S
f : R →+* S
hp : Monic p
map_eq : Polynomial.map f p = 1
✝ : Nontrivial R
⊢ ↑f (Polynomial.leadingCoeff p) ≠ 0

tactic: exact one_ne_zero
state_before: R : Type u
S✝ : Type v
a b : R
m n : ℕ
ι : Type y
inst✝² : Semiring R
p q r : R[X]
S : Type u_1
inst✝¹ : Semiring S
inst✝ : Nontrivial S
f : R →+* S
hp : Monic p
map_eq : Polynomial.map f p = 1
✝ : Nontrivial R
⊢ 1 ≠ 0
Theorem: Finset.mulEtransformRight_inv
File: Mathlib/Combinatorics/Additive/Etransform.lean

tactic: simp [-op_inv, op_smul_eq_smul, mulEtransformLeft, mulEtransformRight]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ mulEtransformRight e⁻¹ x = Prod.swap (mulEtransformLeft e (Prod.swap x))
Theorem: IsPicardLindelof.exists_forall_hasDerivWithinAt_Icc_eq
File: Mathlib/Analysis/ODE/PicardLindelof.lean

tactic: lift C to ℝ≥0 using (norm_nonneg _).trans hpl.norm_le₀
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
v : ℝ → E → E
tMin t₀ tMax : ℝ
x₀ : E
C R : ℝ
L : ℝ≥0
hpl : IsPicardLindelof v tMin t₀ tMax x₀ L R C
⊢ ∃ f, f t₀ = x₀ ∧ ∀ (t : ℝ), t ∈ Icc tMin tMax → HasDerivWithinAt f (v t (f t)) (Icc tMin tMax) t

tactic: lift t₀ to Icc tMin tMax using hpl.ht₀
state_before: case intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
v : ℝ → E → E
tMin t₀ tMax : ℝ
x₀ : E
R : ℝ
L C : ℝ≥0
hpl : IsPicardLindelof v tMin t₀ tMax x₀ L R ↑C
⊢ ∃ f, f t₀ = x₀ ∧ ∀ (t : ℝ), t ∈ Icc tMin tMax → HasDerivWithinAt f (v t (f t)) (Icc tMin tMax) t

tactic: exact PicardLindelof.exists_solution
  ⟨v, tMin, tMax, t₀, x₀, C, ⟨R, hpl.hR⟩, L, { hpl with ht₀ := t₀.property }⟩
state_before: case intro.intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
v : ℝ → E → E
tMin tMax : ℝ
x₀ : E
R : ℝ
L C : ℝ≥0
t₀ : { x // x ∈ Icc tMin tMax }
hpl : IsPicardLindelof v tMin (↑t₀) tMax x₀ L R ↑C
⊢ ∃ f, f ↑t₀ = x₀ ∧ ∀ (t : ℝ), t ∈ Icc tMin tMax → HasDerivWithinAt f (v t (f t)) (Icc tMin tMax) t
Theorem: Submodule.mem_span_singleton_mul
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: rfl
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n x y : A
⊢ x ∈ map (↑(LinearMap.mul R A) y) P ↔ ∃ z, z ∈ P ∧ Mul.mul y z = x
Theorem: midpoint_vsub
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean

tactic: rw [← vsub_sub_vsub_cancel_right p₁ p p₂, smul_sub, sub_eq_add_neg, ← smul_neg,
  neg_vsub_eq_vsub_rev, add_assoc, invOf_two_smul_add_invOf_two_smul, ← vadd_vsub_assoc,
  midpoint_comm, midpoint, lineMap_apply]
state_before: R : Type u_3
V : Type u_1
V' : Type ?u.57244
P : Type u_2
P' : Type ?u.57250
inst✝⁷ : Ring R
inst✝⁶ : Invertible 2
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z p₁ p₂ p : P
⊢ midpoint R p₁ p₂ -ᵥ p = ⅟2 • (p₁ -ᵥ p) + ⅟2 • (p₂ -ᵥ p)
Theorem: Real.IsConjugateExponent.div_conj_eq_sub_one
File: Mathlib/Data/Real/ConjugateExponents.lean

tactic: field_simp [h.symm.ne_zero]
state_before: p q : ℝ
h : IsConjugateExponent p q
⊢ p / q = p - 1

tactic: rw [h.sub_one_mul_conj]
state_before: p q : ℝ
h : IsConjugateExponent p q
⊢ p = (p - 1) * q
Theorem: AddTorsor.connectedSpace
File: Mathlib/Topology/Algebra/MulAction.lean

tactic: convert
  isPreconnected_univ.image (Equiv.vaddConst (Classical.arbitrary P) : G → P)
    (continuous_id.vadd continuous_const).continuousOn
state_before: G : Type ?u.30653
P : Type u_1
inst✝⁵ : AddGroup G
inst✝⁴ : AddTorsor G P
inst✝³ : TopologicalSpace G
inst✝² : PreconnectedSpace G
inst✝¹ : TopologicalSpace P
inst✝ : ContinuousVAdd G P
⊢ IsPreconnected Set.univ

tactic: rw [Set.image_univ, Equiv.range_eq_univ]
state_before: case h.e'_3
G : Type ?u.30653
P : Type u_1
inst✝⁵ : AddGroup G
inst✝⁴ : AddTorsor G P
inst✝³ : TopologicalSpace G
inst✝² : PreconnectedSpace G
inst✝¹ : TopologicalSpace P
inst✝ : ContinuousVAdd G P
⊢ Set.univ = ↑(Equiv.vaddConst (Classical.arbitrary P)) '' Set.univ
Theorem: IntermediateField.adjoin_adjoin_comm
File: Mathlib/FieldTheory/Adjoin.lean

tactic: rw [adjoin_adjoin_left, adjoin_adjoin_left, Set.union_comm]
state_before: F : Type u_2
inst✝² : Field F
E : Type u_1
inst✝¹ : Field E
inst✝ : Algebra F E
S T : Set E
⊢ restrictScalars F (adjoin { x // x ∈ adjoin F S } T) = restrictScalars F (adjoin { x // x ∈ adjoin F T } S)
Theorem: Ordinal.blsub_zero
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [blsub_eq_zero_iff]
state_before: α : Type ?u.358145
β : Type ?u.358148
γ : Type ?u.358151
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
f : (a : Ordinal) → a < 0 → Ordinal
⊢ blsub 0 f = 0
Theorem: UniformSpace.SeparationQuotient.map_unique
File: Mathlib/Topology/UniformSpace/Separation.lean

tactic: ext ⟨a⟩
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
hf : UniformContinuous f
g : SeparationQuotient α → SeparationQuotient β
comm : Quotient.mk (separationSetoid β) ∘ f = g ∘ Quotient.mk (separationSetoid α)
⊢ map f = g

tactic: calc
  map f ⟦a⟧ = ⟦f a⟧ := map_mk hf a
  _ = g ⟦a⟧ := congr_fun comm a
state_before: case h.mk
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
hf : UniformContinuous f
g : SeparationQuotient α → SeparationQuotient β
comm : Quotient.mk (separationSetoid β) ∘ f = g ∘ Quotient.mk (separationSetoid α)
x✝ : SeparationQuotient α
a : α
⊢ map f (Quot.mk Setoid.r a) = g (Quot.mk Setoid.r a)
Theorem: Int.clog_of_left_le_one
File: Mathlib/Data/Int/Log.lean

tactic: rw [← neg_log_inv_eq_clog, log_of_left_le_one hb, neg_zero]
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
hb : b ≤ 1
r : R
⊢ clog b r = 0
Theorem: FractionalIdeal.ne_zero_of_mul_eq_one
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: convert h
state_before: R : Type ?u.1132184
inst✝⁵ : CommRing R
S : Submonoid R
P : Type ?u.1132391
inst✝⁴ : CommRing P
inst✝³ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_1
inst✝² : CommRing R₁
K : Type u_2
inst✝¹ : Field K
inst✝ : Algebra R₁ K
frac : IsFractionRing R₁ K
I J : FractionalIdeal R₁⁰ K
h : I * J = 1
hI : I = 0
⊢ 0 = 1

tactic: simp [hI]
state_before: case h.e'_2
R : Type ?u.1132184
inst✝⁵ : CommRing R
S : Submonoid R
P : Type ?u.1132391
inst✝⁴ : CommRing P
inst✝³ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_1
inst✝² : CommRing R₁
K : Type u_2
inst✝¹ : Field K
inst✝ : Algebra R₁ K
frac : IsFractionRing R₁ K
I J : FractionalIdeal R₁⁰ K
h : I * J = 1
hI : I = 0
⊢ 0 = I * J
Theorem: Cardinal.mk_Prop
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: simp
state_before: α β : Type u
⊢ (#Prop) = 2
Theorem: Set.range_eq_iff
File: Mathlib/Data/Set/Image.lean

tactic: rw [← range_subset_iff]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.71655
ι : Sort ?u.71658
ι' : Sort ?u.71661
f✝ : ι → α
s✝ t : Set α
f : α → β
s : Set β
⊢ range f = s ↔ (∀ (a : α), f a ∈ s) ∧ ∀ (b : β), b ∈ s → ∃ a, f a = b

tactic: exact le_antisymm_iff
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.71655
ι : Sort ?u.71658
ι' : Sort ?u.71661
f✝ : ι → α
s✝ t : Set α
f : α → β
s : Set β
⊢ range f = s ↔ (range fun a => f a) ⊆ s ∧ ∀ (b : β), b ∈ s → ∃ a, f a = b
Theorem: UniqueFactorizationMonoid.dvd_of_dvd_mul_right_of_no_prime_factors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: simpa [mul_comm b c] using dvd_of_dvd_mul_left_of_no_prime_factors ha @no_factors
state_before: α : Type ?u.944204
R : Type u_1
inst✝¹ : CancelCommMonoidWithZero R
inst✝ : UniqueFactorizationMonoid R
a b c : R
ha : a ≠ 0
no_factors : ∀ {d : R}, d ∣ a → d ∣ b → ¬Prime d
⊢ a ∣ b * c → a ∣ c
Theorem: SimpleGraph.Colorable.of_embedding
File: Mathlib/Combinatorics/SimpleGraph/Coloring.lean

tactic: simp
state_before: V : Type u
G : SimpleGraph V
α : Type v
C : Coloring G α
V' : Type u_1
G' : SimpleGraph V'
f : G ↪g G'
n : ℕ
h : Colorable G' n
⊢ n ≤ Fintype.card (Fin n)
Theorem: Real.Angle.sign_coe_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [sign, sin_coe_pi, _root_.sign_zero]
state_before: ⊢ sign ↑π = 0
Theorem: Real.sInf_nonpos
File: Mathlib/Data/Real/Basic.lean

tactic: rcases S.eq_empty_or_nonempty with (rfl | ⟨y, hy⟩)
state_before: x y : ℝ
S : Set ℝ
hS : ∀ (x : ℝ), x ∈ S → x ≤ 0
⊢ sInf S ≤ 0

tactic: exact sInf_empty.le
state_before: case inl
x y : ℝ
hS : ∀ (x : ℝ), x ∈ ∅ → x ≤ 0
⊢ sInf ∅ ≤ 0

tactic: apply dite _ (fun h => csInf_le_of_le h hy <| hS y hy) fun h => (sInf_of_not_bddBelow h).le
state_before: case inr.intro
x y✝ : ℝ
S : Set ℝ
hS : ∀ (x : ℝ), x ∈ S → x ≤ 0
y : ℝ
hy : y ∈ S
⊢ sInf S ≤ 0
Theorem: Filter.inf_principal_eq_bot
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [← empty_mem_iff_bot, mem_inf_principal]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.119534
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : Filter α
s : Set α
⊢ f ⊓ 𝓟 s = ⊥ ↔ sᶜ ∈ f

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.119534
ι : Sort x
f✝ g : Filter α
s✝ t : Set α
f : Filter α
s : Set α
⊢ {x | x ∈ s → x ∈ ∅} ∈ f ↔ sᶜ ∈ f
Theorem: SimpleGraph.degree_lt_card_verts
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: classical
apply Finset.card_lt_card
rw [Finset.ssubset_iff]
exact ⟨v, by simp, Finset.subset_univ _⟩
state_before: ι : Sort ?u.295859
𝕜 : Type ?u.295862
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
⊢ degree G v < Fintype.card V

tactic: apply Finset.card_lt_card
state_before: ι : Sort ?u.295859
𝕜 : Type ?u.295862
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
⊢ degree G v < Fintype.card V

tactic: rw [Finset.ssubset_iff]
state_before: case h
ι : Sort ?u.295859
𝕜 : Type ?u.295862
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
⊢ neighborFinset G v ⊂ univ

tactic: exact ⟨v, by simp, Finset.subset_univ _⟩
state_before: case h
ι : Sort ?u.295859
𝕜 : Type ?u.295862
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
⊢ ∃ a x, insert a (neighborFinset G v) ⊆ univ

tactic: simp
state_before: ι : Sort ?u.295859
𝕜 : Type ?u.295862
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
⊢ ¬v ∈ neighborFinset G v
Theorem: Order.Ioc_pred_right_of_not_isMin
File: Mathlib/Order/SuccPred/Basic.lean

tactic: rw [← Ioi_inter_Iic, Iic_pred_of_not_isMin ha, Ioi_inter_Iio]
state_before: α : Type u_1
inst✝¹ : Preorder α
inst✝ : PredOrder α
a b : α
ha : ¬IsMin b
⊢ Ioc a (pred b) = Ioo a b
Theorem: IsCoprime.add_mul_left_left
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: simpa only [mul_neg, add_neg_cancel_right] using h
state_before: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime (x + y * z + y * -z) y
Theorem: TopologicalGroup.of_nhds_one'
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: rw [show (fun x => x₀ * x * x₀⁻¹) = (fun x => x * x₀⁻¹) ∘ fun x => x₀ * x from rfl, ←
  map_map, ← hleft, hright, map_map]
state_before: α : Type u
β : Type v
G✝ : Type w
H : Type x
inst✝⁵ : TopologicalSpace G✝
inst✝⁴ : Group G✝
inst✝³ : TopologicalGroup G✝
inst✝² : TopologicalSpace α
f : α → G✝
s : Set α
x : α
G : Type u
inst✝¹ : Group G
inst✝ : TopologicalSpace G
hmul : Tendsto (uncurry fun x x_1 => x * x_1) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1)
hinv : Tendsto (fun x => x⁻¹) (𝓝 1) (𝓝 1)
hleft : ∀ (x₀ : G), 𝓝 x₀ = map (fun x => x₀ * x) (𝓝 1)
hright : ∀ (x₀ : G), 𝓝 x₀ = map (fun x => x * x₀) (𝓝 1)
x₀ : G
⊢ map (fun x => x₀ * x * x₀⁻¹) (𝓝 1) = 𝓝 1
Theorem: MeasureTheory.SignedMeasure.null_of_totalVariation_zero
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

tactic: rw [totalVariation, Measure.coe_add, Pi.add_apply, add_eq_zero_iff] at hs
state_before: α : Type u_1
β : Type ?u.88005
inst✝ : MeasurableSpace α
s : SignedMeasure α
i : Set α
hs : ↑↑(totalVariation s) i = 0
⊢ ↑s i = 0

tactic: rw [← toSignedMeasure_toJordanDecomposition s, toSignedMeasure, VectorMeasure.coe_sub,
  Pi.sub_apply, Measure.toSignedMeasure_apply, Measure.toSignedMeasure_apply]
state_before: α : Type u_1
β : Type ?u.88005
inst✝ : MeasurableSpace α
s : SignedMeasure α
i : Set α
hs : ↑↑(toJordanDecomposition s).posPart i = 0 ∧ ↑↑(toJordanDecomposition s).negPart i = 0
⊢ ↑s i = 0

tactic: by_cases hi : MeasurableSet i
state_before: α : Type u_1
β : Type ?u.88005
inst✝ : MeasurableSpace α
s : SignedMeasure α
i : Set α
hs : ↑↑(toJordanDecomposition s).posPart i = 0 ∧ ↑↑(toJordanDecomposition s).negPart i = 0
⊢ ((if MeasurableSet i then ENNReal.toReal (↑↑(toJordanDecomposition s).posPart i) else 0) -
      if MeasurableSet i then ENNReal.toReal (↑↑(toJordanDecomposition s).negPart i) else 0) =
    0

tactic: rw [if_pos hi, if_pos hi]
state_before: case pos
α : Type u_1
β : Type ?u.88005
inst✝ : MeasurableSpace α
s : SignedMeasure α
i : Set α
hs : ↑↑(toJordanDecomposition s).posPart i = 0 ∧ ↑↑(toJordanDecomposition s).negPart i = 0
hi : MeasurableSet i
⊢ ((if MeasurableSet i then ENNReal.toReal (↑↑(toJordanDecomposition s).posPart i) else 0) -
      if MeasurableSet i then ENNReal.toReal (↑↑(toJordanDecomposition s).negPart i) else 0) =
    0

tactic: simp [hs.1, hs.2]
state_before: case pos
α : Type u_1
β : Type ?u.88005
inst✝ : MeasurableSpace α
s : SignedMeasure α
i : Set α
hs : ↑↑(toJordanDecomposition s).posPart i = 0 ∧ ↑↑(toJordanDecomposition s).negPart i = 0
hi : MeasurableSet i
⊢ ENNReal.toReal (↑↑(toJordanDecomposition s).posPart i) - ENNReal.toReal (↑↑(toJordanDecomposition s).negPart i) = 0

tactic: simp [if_neg hi]
state_before: case neg
α : Type u_1
β : Type ?u.88005
inst✝ : MeasurableSpace α
s : SignedMeasure α
i : Set α
hs : ↑↑(toJordanDecomposition s).posPart i = 0 ∧ ↑↑(toJordanDecomposition s).negPart i = 0
hi : ¬MeasurableSet i
⊢ ((if MeasurableSet i then ENNReal.toReal (↑↑(toJordanDecomposition s).posPart i) else 0) -
      if MeasurableSet i then ENNReal.toReal (↑↑(toJordanDecomposition s).negPart i) else 0) =
    0
Theorem: CategoryTheory.Limits.Multicoequalizer.hom_ext
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

tactic: rintro (a | b)
state_before: C : Type u
inst✝¹ : Category C
I : MultispanIndex C
inst✝ : HasMulticoequalizer I
W : C
i j : multicoequalizer I ⟶ W
h : ∀ (b : I.R), π I b ≫ i = π I b ≫ j
⊢ ∀ (j_1 : WalkingMultispan I.fstFrom I.sndFrom),
    colimit.ι (MultispanIndex.multispan I) j_1 ≫ i = colimit.ι (MultispanIndex.multispan I) j_1 ≫ j

tactic: simp_rw [← colimit.w I.multispan (WalkingMultispan.Hom.fst a), Category.assoc, h]
state_before: case left
C : Type u
inst✝¹ : Category C
I : MultispanIndex C
inst✝ : HasMulticoequalizer I
W : C
i j : multicoequalizer I ⟶ W
h : ∀ (b : I.R), π I b ≫ i = π I b ≫ j
a : I.L
⊢ colimit.ι (MultispanIndex.multispan I) (WalkingMultispan.left a) ≫ i =
    colimit.ι (MultispanIndex.multispan I) (WalkingMultispan.left a) ≫ j

tactic: apply h
state_before: case right
C : Type u
inst✝¹ : Category C
I : MultispanIndex C
inst✝ : HasMulticoequalizer I
W : C
i j : multicoequalizer I ⟶ W
h : ∀ (b : I.R), π I b ≫ i = π I b ≫ j
b : I.R
⊢ colimit.ι (MultispanIndex.multispan I) (WalkingMultispan.right b) ≫ i =
    colimit.ι (MultispanIndex.multispan I) (WalkingMultispan.right b) ≫ j
Theorem: Finsupp.prod_mapDomain_index_inj
File: Mathlib/Data/Finsupp/Basic.lean

tactic: rw [← Function.Embedding.coeFn_mk f hf, ← embDomain_eq_mapDomain, prod_embDomain]
state_before: α : Type u_2
β : Type u_4
γ : Type ?u.249071
ι : Type ?u.249074
M : Type u_3
M' : Type ?u.249080
N : Type u_1
P : Type ?u.249086
G : Type ?u.249089
H : Type ?u.249092
R : Type ?u.249095
S : Type ?u.249098
inst✝¹ : AddCommMonoid M
v v₁ v₂ : α →₀ M
inst✝ : CommMonoid N
f : α → β
s : α →₀ M
h : β → M → N
hf : Injective f
⊢ prod (mapDomain f s) h = prod s fun a b => h (f a) b
Theorem: Urysohns.CU.approx_of_nmem_U
File: Mathlib/Topology/UrysohnsLemma.lean

tactic: induction' n with n ihn generalizing c
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c : CU X
n : ℕ
x : X
hx : ¬x ∈ c.U
⊢ approx n c x = 1

tactic: rw [← mem_compl_iff] at hx
state_before: case zero
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c✝ : CU X
x : X
hx✝ : ¬x ∈ c✝.U
c : CU X
hx : ¬x ∈ c.U
⊢ approx Nat.zero c x = 1

tactic: exact indicator_of_mem hx _
state_before: case zero
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c✝ : CU X
x : X
hx✝ : ¬x ∈ c✝.U
c : CU X
hx : x ∈ c.Uᶜ
⊢ approx Nat.zero c x = 1

tactic: simp only [approx]
state_before: case succ
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c✝ : CU X
x : X
hx✝ : ¬x ∈ c✝.U
n : ℕ
ihn : ∀ (c : CU X), ¬x ∈ c.U → approx n c x = 1
c : CU X
hx : ¬x ∈ c.U
⊢ approx (Nat.succ n) c x = 1

tactic: rw [ihn, ihn, midpoint_self]
state_before: case succ
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c✝ : CU X
x : X
hx✝ : ¬x ∈ c✝.U
n : ℕ
ihn : ∀ (c : CU X), ¬x ∈ c.U → approx n c x = 1
c : CU X
hx : ¬x ∈ c.U
⊢ midpoint ℝ (approx n (left c) x) (approx n (right c) x) = 1

tactic: exacts [hx, fun hU => hx <| c.left_U_subset hU]
state_before: case succ.hx
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c✝ : CU X
x : X
hx✝ : ¬x ∈ c✝.U
n : ℕ
ihn : ∀ (c : CU X), ¬x ∈ c.U → approx n c x = 1
c : CU X
hx : ¬x ∈ c.U
⊢ ¬x ∈ (right c).U

case succ.hx
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c✝ : CU X
x : X
hx✝ : ¬x ∈ c✝.U
n : ℕ
ihn : ∀ (c : CU X), ¬x ∈ c.U → approx n c x = 1
c : CU X
hx : ¬x ∈ c.U
⊢ ¬x ∈ (left c).U
Theorem: Real.lt_rpow_of_log_lt
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: obtain hx | rfl := hx.lt_or_eq
state_before: x y z : ℝ
hx : 0 ≤ x
hy : 0 < y
h : log x < z * log y
⊢ x < y ^ z

tactic: exact Real.rpow_pos_of_pos hy z
state_before: case inr
y z : ℝ
hy : 0 < y
hx : 0 ≤ 0
h : log 0 < z * log y
⊢ 0 < y ^ z

tactic: exact (lt_rpow_iff_log_lt hx hy).2 h
state_before: case inl
x y z : ℝ
hx✝ : 0 ≤ x
hy : 0 < y
h : log x < z * log y
hx : 0 < x
⊢ x < y ^ z
Theorem: exists_linearIndependent
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: obtain ⟨b, hb₁, -, hb₂, hb₃⟩ :=
  exists_linearIndependent_extension (linearIndependent_empty K V) (Set.empty_subset t)
state_before: ι : Type u'
ι' : Type ?u.1261935
R : Type ?u.1261938
K : Type u_1
M : Type ?u.1261944
M' : Type ?u.1261947
M'' : Type ?u.1261950
V : Type u
V' : Type ?u.1261955
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
⊢ ∃ b x, span K b = span K t ∧ LinearIndependent K Subtype.val

tactic: exact ⟨b, hb₁, (span_eq_of_le _ hb₂ (Submodule.span_mono hb₁)).symm, hb₃⟩
state_before: case intro.intro.intro.intro
ι : Type u'
ι' : Type ?u.1261935
R : Type ?u.1261938
K : Type u_1
M : Type ?u.1261944
M' : Type ?u.1261947
M'' : Type ?u.1261950
V : Type u
V' : Type ?u.1261955
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
b : Set V
hb₁ : b ⊆ t
hb₂ : t ⊆ ↑(span K b)
hb₃ : LinearIndependent K Subtype.val
⊢ ∃ b x, span K b = span K t ∧ LinearIndependent K Subtype.val
Theorem: Set.countable_insert
File: Mathlib/Data/Set/Countable.lean

tactic: simp only [insert_eq, countable_union, countable_singleton, true_and_iff]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
a : α
⊢ Set.Countable (insert a s) ↔ Set.Countable s