tasksource/leandojo huggingface dataset:
Theorem: HahnSeries.mul_coeff_left'
File: Mathlib/RingTheory/HahnSeries.lean

tactic: rw [mul_coeff]
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
a : Γ
s : Set Γ
hs : Set.IsPwo s
hxs : support x ⊆ s
⊢ coeff (x * y) a = ∑ ij in addAntidiagonal hs (_ : Set.IsPwo (support y)) a, coeff x ij.fst * coeff y ij.snd

tactic: apply sum_subset_zero_on_sdiff (addAntidiagonal_mono_left hxs) _ fun _ _ => rfl
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
a : Γ
s : Set Γ
hs : Set.IsPwo s
hxs : support x ⊆ s
⊢ ∑ ij in addAntidiagonal (_ : Set.IsPwo (support x)) (_ : Set.IsPwo (support y)) a, coeff x ij.fst * coeff y ij.snd =
    ∑ ij in addAntidiagonal hs (_ : Set.IsPwo (support y)) a, coeff x ij.fst * coeff y ij.snd

tactic: intro b hb
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
a : Γ
s : Set Γ
hs : Set.IsPwo s
hxs : support x ⊆ s
⊢ ∀ (x_1 : Γ × Γ),
    x_1 ∈
        addAntidiagonal hs (_ : Set.IsPwo (support y)) a \
          addAntidiagonal (_ : Set.IsPwo (support x)) (_ : Set.IsPwo (support y)) a →
      coeff x x_1.fst * coeff y x_1.snd = 0

tactic: simp only [not_and', mem_sdiff, mem_addAntidiagonal, mem_support, not_ne_iff] at hb
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
a : Γ
s : Set Γ
hs : Set.IsPwo s
hxs : support x ⊆ s
b : Γ × Γ
hb :
  b ∈
    addAntidiagonal hs (_ : Set.IsPwo (support y)) a \
      addAntidiagonal (_ : Set.IsPwo (support x)) (_ : Set.IsPwo (support y)) a
⊢ coeff x b.fst * coeff y b.snd = 0

tactic: rw [hb.2 ⟨hb.1.2.1, hb.1.2.2⟩, MulZeroClass.zero_mul]
state_before: Γ : Type u_2
R : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
a : Γ
s : Set Γ
hs : Set.IsPwo s
hxs : support x ⊆ s
b : Γ × Γ
hb : (b.fst ∈ s ∧ coeff y b.snd ≠ 0 ∧ b.fst + b.snd = a) ∧ (coeff y b.snd ≠ 0 ∧ b.fst + b.snd = a → coeff x b.fst = 0)
⊢ coeff x b.fst * coeff y b.snd = 0
Theorem: Finset.coe_symmDiff
File: Mathlib/Data/Finset/Basic.lean

tactic: simp [mem_symmDiff, Set.mem_symmDiff]
state_before: α : Type u_1
β : Type ?u.286326
γ : Type ?u.286329
inst✝ : DecidableEq α
s t : Finset α
a b x : α
⊢ x ∈ ↑(s ∆ t) ↔ x ∈ ↑s ∆ ↑t
Theorem: lp.eq_zero_iff_coeFn_eq_zero
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: rw [lp.ext_iff, coeFn_zero]
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E p }
⊢ f = 0 ↔ ↑f = 0
Theorem: Multiset.disjoint_singleton
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [disjoint_comm, singleton_disjoint]
state_before: α : Type u_1
β : Type ?u.484138
γ : Type ?u.484141
l : Multiset α
a : α
⊢ Disjoint l {a} ↔ ¬a ∈ l
Theorem: mul_eq_of_eq_div
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp [h]
state_before: α : Type ?u.59709
β : Type ?u.59712
G : Type u_1
inst✝ : Group G
a b c d : G
h : a = c / b
⊢ a * b = c
Theorem: Int.neg_add_cancel_left
File: Std/Data/Int/Lemmas.lean

tactic: rw [← Int.add_assoc, Int.add_left_neg, Int.zero_add]
state_before: a b : Int
⊢ -a + (a + b) = b
Theorem: MeasureTheory.Measure.withDensity_rnDeriv_toReal_eq
File: Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean

tactic: rw [integral_toReal, ← withDensity_apply _ hi, withDensity_rnDeriv_eq μ ν h]
state_before: α : Type u_1
β : Type ?u.2764
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : HaveLebesgueDecomposition μ ν
h : μ ≪ ν
i : Set α
hi : MeasurableSet i
⊢ (∫ (x : α) in i, ENNReal.toReal (rnDeriv μ ν x) ∂ν) = ENNReal.toReal (↑↑μ i)

tactic: measurability
state_before: case hfm
α : Type u_1
β : Type ?u.2764
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : HaveLebesgueDecomposition μ ν
h : μ ≪ ν
i : Set α
hi : MeasurableSet i
⊢ AEMeasurable fun x => rnDeriv μ ν x

tactic: refine' ae_lt_top (μ.measurable_rnDeriv ν)
  (lt_of_le_of_lt (lintegral_mono_set i.subset_univ) _).ne
state_before: case hf
α : Type u_1
β : Type ?u.2764
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : HaveLebesgueDecomposition μ ν
h : μ ≪ ν
i : Set α
hi : MeasurableSet i
⊢ ∀ᵐ (x : α) ∂restrict ν i, rnDeriv μ ν x < ⊤

tactic: rw [← withDensity_apply _ MeasurableSet.univ, withDensity_rnDeriv_eq μ ν h]
state_before: case hf
α : Type u_1
β : Type ?u.2764
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : HaveLebesgueDecomposition μ ν
h : μ ≪ ν
i : Set α
hi : MeasurableSet i
⊢ (∫⁻ (x : α) in Set.univ, rnDeriv μ ν x ∂ν) < ⊤

tactic: exact measure_lt_top _ _
state_before: case hf
α : Type u_1
β : Type ?u.2764
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : HaveLebesgueDecomposition μ ν
h : μ ≪ ν
i : Set α
hi : MeasurableSet i
⊢ ↑↑μ Set.univ < ⊤
Theorem: mul_mem_nonZeroDivisors
File: Mathlib/RingTheory/NonZeroDivisors.lean

tactic: constructor
state_before: M : Type ?u.20654
M' : Type ?u.20657
M₁ : Type u_1
R : Type ?u.20663
R' : Type ?u.20666
F : Type ?u.20669
inst✝⁴ : MonoidWithZero M
inst✝³ : MonoidWithZero M'
inst✝² : CommMonoidWithZero M₁
inst✝¹ : Ring R
inst✝ : CommRing R'
a b : M₁
⊢ a * b ∈ M₁⁰ ↔ a ∈ M₁⁰ ∧ b ∈ M₁⁰

tactic: intro h
state_before: case mp
M : Type ?u.20654
M' : Type ?u.20657
M₁ : Type u_1
R : Type ?u.20663
R' : Type ?u.20666
F : Type ?u.20669
inst✝⁴ : MonoidWithZero M
inst✝³ : MonoidWithZero M'
inst✝² : CommMonoidWithZero M₁
inst✝¹ : Ring R
inst✝ : CommRing R'
a b : M₁
⊢ a * b ∈ M₁⁰ → a ∈ M₁⁰ ∧ b ∈ M₁⁰

tactic: constructor <;> intro x h' <;> apply h
state_before: case mp
M : Type ?u.20654
M' : Type ?u.20657
M₁ : Type u_1
R : Type ?u.20663
R' : Type ?u.20666
F : Type ?u.20669
inst✝⁴ : MonoidWithZero M
inst✝³ : MonoidWithZero M'
inst✝² : CommMonoidWithZero M₁
inst✝¹ : Ring R
inst✝ : CommRing R'
a b : M₁
h : a * b ∈ M₁⁰
⊢ a ∈ M₁⁰ ∧ b ∈ M₁⁰

tactic: rw [← mul_assoc, h', zero_mul]
state_before: case mp.left.a
M : Type ?u.20654
M' : Type ?u.20657
M₁ : Type u_1
R : Type ?u.20663
R' : Type ?u.20666
F : Type ?u.20669
inst✝⁴ : MonoidWithZero M
inst✝³ : MonoidWithZero M'
inst✝² : CommMonoidWithZero M₁
inst✝¹ : Ring R
inst✝ : CommRing R'
a b : M₁
h : a * b ∈ M₁⁰
x : M₁
h' : x * a = 0
⊢ x * (a * b) = 0

tactic: rw [mul_comm a b, ← mul_assoc, h', zero_mul]
state_before: case mp.right.a
M : Type ?u.20654
M' : Type ?u.20657
M₁ : Type u_1
R : Type ?u.20663
R' : Type ?u.20666
F : Type ?u.20669
inst✝⁴ : MonoidWithZero M
inst✝³ : MonoidWithZero M'
inst✝² : CommMonoidWithZero M₁
inst✝¹ : Ring R
inst✝ : CommRing R'
a b : M₁
h : a * b ∈ M₁⁰
x : M₁
h' : x * b = 0
⊢ x * (a * b) = 0

tactic: rintro ⟨ha, hb⟩ x hx
state_before: case mpr
M : Type ?u.20654
M' : Type ?u.20657
M₁ : Type u_1
R : Type ?u.20663
R' : Type ?u.20666
F : Type ?u.20669
inst✝⁴ : MonoidWithZero M
inst✝³ : MonoidWithZero M'
inst✝² : CommMonoidWithZero M₁
inst✝¹ : Ring R
inst✝ : CommRing R'
a b : M₁
⊢ a ∈ M₁⁰ ∧ b ∈ M₁⁰ → a * b ∈ M₁⁰

tactic: apply ha
state_before: case mpr.intro
M : Type ?u.20654
M' : Type ?u.20657
M₁ : Type u_1
R : Type ?u.20663
R' : Type ?u.20666
F : Type ?u.20669
inst✝⁴ : MonoidWithZero M
inst✝³ : MonoidWithZero M'
inst✝² : CommMonoidWithZero M₁
inst✝¹ : Ring R
inst✝ : CommRing R'
a b : M₁
ha : a ∈ M₁⁰
hb : b ∈ M₁⁰
x : M₁
hx : x * (a * b) = 0
⊢ x = 0

tactic: apply hb
state_before: case mpr.intro.a
M : Type ?u.20654
M' : Type ?u.20657
M₁ : Type u_1
R : Type ?u.20663
R' : Type ?u.20666
F : Type ?u.20669
inst✝⁴ : MonoidWithZero M
inst✝³ : MonoidWithZero M'
inst✝² : CommMonoidWithZero M₁
inst✝¹ : Ring R
inst✝ : CommRing R'
a b : M₁
ha : a ∈ M₁⁰
hb : b ∈ M₁⁰
x : M₁
hx : x * (a * b) = 0
⊢ x * a = 0

tactic: rw [mul_assoc, hx]
state_before: case mpr.intro.a.a
M : Type ?u.20654
M' : Type ?u.20657
M₁ : Type u_1
R : Type ?u.20663
R' : Type ?u.20666
F : Type ?u.20669
inst✝⁴ : MonoidWithZero M
inst✝³ : MonoidWithZero M'
inst✝² : CommMonoidWithZero M₁
inst✝¹ : Ring R
inst✝ : CommRing R'
a b : M₁
ha : a ∈ M₁⁰
hb : b ∈ M₁⁰
x : M₁
hx : x * (a * b) = 0
⊢ x * a * b = 0
Theorem: Finset.Ioo_subset_Ioi_self
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: simpa [← coe_subset] using Set.Ioo_subset_Ioi_self
state_before: ι : Type ?u.49166
α : Type u_1
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝ : LocallyFiniteOrderTop α
⊢ Ioo a b ⊆ Ioi a
Theorem: ite_and_mul_zero
File: Mathlib/Algebra/Ring/Defs.lean

tactic: simp only [← ite_and, ite_mul, mul_ite, mul_zero, zero_mul, and_comm]
state_before: α✝ : Type u
β : Type v
γ : Type w
R : Type x
α : Type u_1
inst✝² : MulZeroClass α
P Q : Prop
inst✝¹ : Decidable P
inst✝ : Decidable Q
a b : α
⊢ (if P ∧ Q then a * b else 0) = (if P then a else 0) * if Q then b else 0
Theorem: Polynomial.support_X_empty
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rw [X, H, monomial_zero_right, support_zero]
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
H : 1 = 0
⊢ support X = ∅
Theorem: Real.summable_abs_int_rpow
File: Mathlib/Analysis/PSeries.lean

tactic: refine'
  summable_int_of_summable_nat (_ : Summable fun n : ℕ => |(n : ℝ)| ^ _)
    (_ : Summable fun n : ℕ => |((-n : ℤ) : ℝ)| ^ _)
state_before: b : ℝ
hb : 1 < b
⊢ Summable fun n => abs ↑n ^ (-b)

tactic: on_goal 2 => simp_rw [Int.cast_neg, Int.cast_ofNat, abs_neg]
state_before: case refine'_1
b : ℝ
hb : 1 < b
⊢ Summable fun n => abs ↑n ^ (-b)

case refine'_2
b : ℝ
hb : 1 < b
⊢ Summable fun n => abs ↑(-↑n) ^ (-b)

tactic: all_goals
  simp_rw [fun n : ℕ => abs_of_nonneg (n.cast_nonneg : 0 ≤ (n : ℝ))]
  rwa [Real.summable_nat_rpow, neg_lt_neg_iff]
state_before: case refine'_1
b : ℝ
hb : 1 < b
⊢ Summable fun n => abs ↑n ^ (-b)

case refine'_2
b : ℝ
hb : 1 < b
⊢ Summable fun n => abs ↑n ^ (-b)

tactic: simp_rw [Int.cast_neg, Int.cast_ofNat, abs_neg]
state_before: case refine'_2
b : ℝ
hb : 1 < b
⊢ Summable fun n => abs ↑(-↑n) ^ (-b)

tactic: simp_rw [Int.cast_neg, Int.cast_ofNat, abs_neg]
state_before: case refine'_2
b : ℝ
hb : 1 < b
⊢ Summable fun n => abs ↑(-↑n) ^ (-b)

tactic: simp_rw [fun n : ℕ => abs_of_nonneg (n.cast_nonneg : 0 ≤ (n : ℝ))]
state_before: case refine'_2
b : ℝ
hb : 1 < b
⊢ Summable fun n => abs ↑n ^ (-b)

tactic: rwa [Real.summable_nat_rpow, neg_lt_neg_iff]
state_before: case refine'_2
b : ℝ
hb : 1 < b
⊢ Summable fun n => ↑n ^ (-b)
Theorem: Matrix.Represents.one
File: Mathlib/LinearAlgebra/Matrix/Charpoly/LinearMap.lean

tactic: delta Matrix.Represents PiToModule.fromMatrix
state_before: ι : Type u_1
inst✝⁴ : Fintype ι
M : Type u_2
inst✝³ : AddCommGroup M
R : Type u_3
inst✝² : CommRing R
inst✝¹ : Module R M
I : Ideal R
b : ι → M
hb : Submodule.span R (Set.range b) = ⊤
inst✝ : DecidableEq ι
⊢ Represents b 1 1

tactic: rw [LinearMap.comp_apply, AlgEquiv.toLinearMap_apply, _root_.map_one]
state_before: ι : Type u_1
inst✝⁴ : Fintype ι
M : Type u_2
inst✝³ : AddCommGroup M
R : Type u_3
inst✝² : CommRing R
inst✝¹ : Module R M
I : Ideal R
b : ι → M
hb : Submodule.span R (Set.range b) = ⊤
inst✝ : DecidableEq ι
⊢ ↑(LinearMap.comp (↑(LinearMap.llcomp R (ι → R) (ι → R) M) (↑(Fintype.total R R) b))
          (AlgEquiv.toLinearMap (AlgEquiv.symm algEquivMatrix')))
      1 =
    ↑(PiToModule.fromEnd R b) 1

tactic: ext
state_before: ι : Type u_1
inst✝⁴ : Fintype ι
M : Type u_2
inst✝³ : AddCommGroup M
R : Type u_3
inst✝² : CommRing R
inst✝¹ : Module R M
I : Ideal R
b : ι → M
hb : Submodule.span R (Set.range b) = ⊤
inst✝ : DecidableEq ι
⊢ ↑(↑(LinearMap.llcomp R (ι → R) (ι → R) M) (↑(Fintype.total R R) b)) 1 = ↑(PiToModule.fromEnd R b) 1

tactic: rfl
state_before: case h.h
ι : Type u_1
inst✝⁴ : Fintype ι
M : Type u_2
inst✝³ : AddCommGroup M
R : Type u_3
inst✝² : CommRing R
inst✝¹ : Module R M
I : Ideal R
b : ι → M
hb : Submodule.span R (Set.range b) = ⊤
inst✝ : DecidableEq ι
i✝ : ι
⊢ ↑(LinearMap.comp (↑(↑(LinearMap.llcomp R (ι → R) (ι → R) M) (↑(Fintype.total R R) b)) 1) (LinearMap.single i✝)) 1 =
    ↑(LinearMap.comp (↑(PiToModule.fromEnd R b) 1) (LinearMap.single i✝)) 1
Theorem: ZMod.valMinAbs_natCast_of_half_lt
File: Mathlib/Data/ZMod/Basic.lean

tactic: cases n
state_before: n a : ℕ
ha : n / 2 < a
ha' : a < n
⊢ valMinAbs ↑a = ↑a - ↑n

tactic: cases not_lt_bot ha'
state_before: case zero
a : ℕ
ha : Nat.zero / 2 < a
ha' : a < Nat.zero
⊢ valMinAbs ↑a = ↑a - ↑Nat.zero

tactic: simp [valMinAbs_def_pos, val_nat_cast, Nat.mod_eq_of_lt ha', ha.not_le]
state_before: case succ
a n✝ : ℕ
ha : Nat.succ n✝ / 2 < a
ha' : a < Nat.succ n✝
⊢ valMinAbs ↑a = ↑a - ↑(Nat.succ n✝)
Theorem: Fin.predAbove_last_apply
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [predAbove_last]
state_before: n m : ℕ
i : Fin n
⊢ predAbove (last n) ↑↑i = castPred ↑↑i
Theorem: SimpleGraph.Walk.cons_isCycle_iff
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp only [Walk.isCycle_def, Walk.isPath_def, Walk.isTrail_def, edges_cons, List.nodup_cons,
  support_cons, List.tail_cons]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G v u
h : Adj G u v
⊢ IsCycle (cons h p) ↔ IsPath p ∧ ¬Quotient.mk (Sym2.Rel.setoid V) (u, v) ∈ edges p

tactic: have : p.support.Nodup → p.edges.Nodup := edges_nodup_of_support_nodup
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G v u
h : Adj G u v
⊢ (¬Quotient.mk (Sym2.Rel.setoid V) (u, v) ∈ edges p ∧ List.Nodup (edges p)) ∧ cons h p ≠ nil ∧ List.Nodup (support p) ↔
    List.Nodup (support p) ∧ ¬Quotient.mk (Sym2.Rel.setoid V) (u, v) ∈ edges p

tactic: tauto
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G v u
h : Adj G u v
this : List.Nodup (support p) → List.Nodup (edges p)
⊢ (¬Quotient.mk (Sym2.Rel.setoid V) (u, v) ∈ edges p ∧ List.Nodup (edges p)) ∧ cons h p ≠ nil ∧ List.Nodup (support p) ↔
    List.Nodup (support p) ∧ ¬Quotient.mk (Sym2.Rel.setoid V) (u, v) ∈ edges p
Theorem: Real.lt_rpow_inv_iff_of_neg
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: have hz' : 0 < -z := by rwa [lt_neg, neg_zero]
state_before: x y z : ℝ
hx : 0 < x
hy : 0 < y
hz : z < 0
⊢ x < y ^ z⁻¹ ↔ y < x ^ z

tactic: have hxz : 0 < x ^ (-z) := Real.rpow_pos_of_pos hx _
state_before: x y z : ℝ
hx : 0 < x
hy : 0 < y
hz : z < 0
hz' : 0 < -z
⊢ x < y ^ z⁻¹ ↔ y < x ^ z

tactic: have hyz : 0 < y ^ z⁻¹ := Real.rpow_pos_of_pos hy _
state_before: x y z : ℝ
hx : 0 < x
hy : 0 < y
hz : z < 0
hz' : 0 < -z
hxz : 0 < x ^ (-z)
⊢ x < y ^ z⁻¹ ↔ y < x ^ z

tactic: rw [← Real.rpow_lt_rpow_iff hx.le hyz.le hz', ← Real.rpow_mul hy.le]
state_before: x y z : ℝ
hx : 0 < x
hy : 0 < y
hz : z < 0
hz' : 0 < -z
hxz : 0 < x ^ (-z)
hyz : 0 < y ^ z⁻¹
⊢ x < y ^ z⁻¹ ↔ y < x ^ z

tactic: simp only [ne_of_lt hz, Real.rpow_neg_one, mul_neg, inv_mul_cancel, Ne.def, not_false_iff]
state_before: x y z : ℝ
hx : 0 < x
hy : 0 < y
hz : z < 0
hz' : 0 < -z
hxz : 0 < x ^ (-z)
hyz : 0 < y ^ z⁻¹
⊢ x ^ (-z) < y ^ (z⁻¹ * -z) ↔ y < x ^ z

tactic: rw [lt_inv hxz hy, ← Real.rpow_neg_one, ← Real.rpow_mul hx.le]
state_before: x y z : ℝ
hx : 0 < x
hy : 0 < y
hz : z < 0
hz' : 0 < -z
hxz : 0 < x ^ (-z)
hyz : 0 < y ^ z⁻¹
⊢ x ^ (-z) < y⁻¹ ↔ y < x ^ z

tactic: simp
state_before: x y z : ℝ
hx : 0 < x
hy : 0 < y
hz : z < 0
hz' : 0 < -z
hxz : 0 < x ^ (-z)
hyz : 0 < y ^ z⁻¹
⊢ y < x ^ (-z * -1) ↔ y < x ^ z

tactic: rwa [lt_neg, neg_zero]
state_before: x y z : ℝ
hx : 0 < x
hy : 0 < y
hz : z < 0
⊢ 0 < -z
Theorem: measure_le_lintegral_thickenedIndicator
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: convert measure_le_lintegral_thickenedIndicatorAux μ E_mble δ
state_before: α : Type u_1
β : Type ?u.5010653
E✝ : Type ?u.5010656
F : Type ?u.5010659
inst✝² : MeasurableSpace α
ι : Type ?u.5010665
inst✝¹ : NormedAddCommGroup E✝
inst✝ : PseudoEMetricSpace α
μ : MeasureTheory.Measure α
E : Set α
E_mble : MeasurableSet E
δ : ℝ
δ_pos : 0 < δ
⊢ ↑↑μ E ≤ ∫⁻ (a : α), ↑(↑(thickenedIndicator δ_pos E) a) ∂μ

tactic: dsimp
state_before: case h.e'_4.h.e'_4.h
α : Type u_1
β : Type ?u.5010653
E✝ : Type ?u.5010656
F : Type ?u.5010659
inst✝² : MeasurableSpace α
ι : Type ?u.5010665
inst✝¹ : NormedAddCommGroup E✝
inst✝ : PseudoEMetricSpace α
μ : MeasureTheory.Measure α
E : Set α
E_mble : MeasurableSet E
δ : ℝ
δ_pos : 0 < δ
x✝ : α
⊢ ↑(↑(thickenedIndicator δ_pos E) x✝) = thickenedIndicatorAux δ E x✝

tactic: simp only [thickenedIndicatorAux_lt_top.ne, ENNReal.coe_toNNReal, Ne.def, not_false_iff]
state_before: case h.e'_4.h.e'_4.h
α : Type u_1
β : Type ?u.5010653
E✝ : Type ?u.5010656
F : Type ?u.5010659
inst✝² : MeasurableSpace α
ι : Type ?u.5010665
inst✝¹ : NormedAddCommGroup E✝
inst✝ : PseudoEMetricSpace α
μ : MeasureTheory.Measure α
E : Set α
E_mble : MeasurableSet E
δ : ℝ
δ_pos : 0 < δ
x✝ : α
⊢ ↑(ENNReal.toNNReal (thickenedIndicatorAux δ E x✝)) = thickenedIndicatorAux δ E x✝
Theorem: MvPowerSeries.map_monomial
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: ext m
state_before: σ : Type u_1
R : Type u_3
S : Type u_2
T : Type ?u.869997
inst✝² : Semiring R
inst✝¹ : Semiring S
inst✝ : Semiring T
f : R →+* S
g : S →+* T
n : σ →₀ ℕ
a : R
⊢ ↑(map σ f) (↑(monomial R n) a) = ↑(monomial S n) (↑f a)

tactic: simp [coeff_monomial, apply_ite f]
state_before: case h
σ : Type u_1
R : Type u_3
S : Type u_2
T : Type ?u.869997
inst✝² : Semiring R
inst✝¹ : Semiring S
inst✝ : Semiring T
f : R →+* S
g : S →+* T
n : σ →₀ ℕ
a : R
m : σ →₀ ℕ
⊢ ↑(coeff S m) (↑(map σ f) (↑(monomial R n) a)) = ↑(coeff S m) (↑(monomial S n) (↑f a))
Theorem: Finset.Icc_diff_Ico_self
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: simp [← coe_inj, h]
state_before: ι : Type ?u.95633
α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a b c : α
inst✝ : DecidableEq α
h : a ≤ b
⊢ Icc a b \ Ico a b = {b}
Theorem: CategoryTheory.OplaxNatTrans.Modification.whiskerLeft_naturality
File: Mathlib/CategoryTheory/Bicategory/NaturalTransformation.lean

tactic: simp_rw [← whiskerLeft_comp, naturality]
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G : OplaxFunctor B C
η θ ι : F ⟶ G
Γ : Modification η θ
a b c : B
a' : C
f : a' ⟶ (↑F.toPrelaxFunctor).obj b
g : b ⟶ c
⊢ f ◁ (↑F.toPrelaxFunctor).map g ◁ app Γ c ≫ f ◁ OplaxNatTrans.naturality θ g =
    f ◁ OplaxNatTrans.naturality η g ≫ f ◁ app Γ b ▷ (↑G.toPrelaxFunctor).map g
Theorem: CategoryTheory.Limits.pullbackZeroZeroIso_hom_snd
File: Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean

tactic: simp [← Iso.eq_inv_comp]
state_before: C : Type u_2
inst✝³ : Category C
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : HasBinaryProduct X Y
⊢ (pullbackZeroZeroIso X Y).hom ≫ prod.snd = pullback.snd
Theorem: Set.preimage_sInter
File: Mathlib/Data/Set/Lattice.lean

tactic: rw [sInter_eq_biInter, preimage_iInter₂]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.226389
ι : Sort ?u.226392
ι' : Sort ?u.226395
ι₂ : Sort ?u.226398
κ : ι → Sort ?u.226403
κ₁ : ι → Sort ?u.226408
κ₂ : ι → Sort ?u.226413
κ' : ι' → Sort ?u.226418
f : α → β
s : Set (Set β)
⊢ f ⁻¹' ⋂₀ s = ⋂ (t : Set β) (_ : t ∈ s), f ⁻¹' t
Theorem: Complex.map_exp_comap_re_atTop
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: rw [← comap_exp_comap_abs_atTop, map_comap, range_exp, inf_eq_left, le_principal_iff]
state_before: ⊢ map exp (comap re atTop) = comap (↑abs) atTop

tactic: exact eventually_ne_of_tendsto_norm_atTop tendsto_comap 0
state_before: ⊢ {0}ᶜ ∈ comap (↑abs) atTop
Theorem: List.Perm.union_right
File: Mathlib/Data/List/Perm.lean

tactic: induction' h with a _ _ _ ih _ _ _ _ _ _ _ _ ih_1 ih_2 <;> try simp
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
l₁ l₂ t₁ : List α
h : l₁ ~ l₂
⊢ List.union l₁ t₁ ~ List.union l₂ t₁

tactic: simp
state_before: case trans
α : Type uu
β : Type vv
l₁✝¹ l₂✝¹ : List α
inst✝ : DecidableEq α
l₁ l₂ t₁ l₁✝ l₂✝ l₃✝ : List α
a✝¹ : l₁✝ ~ l₂✝
a✝ : l₂✝ ~ l₃✝
ih_1 : List.union l₁✝ t₁ ~ List.union l₂✝ t₁
ih_2 : List.union l₂✝ t₁ ~ List.union l₃✝ t₁
⊢ List.union l₁✝ t₁ ~ List.union l₃✝ t₁

tactic: exact ih.insert a
state_before: case cons
α : Type uu
β : Type vv
l₁✝¹ l₂✝¹ : List α
inst✝ : DecidableEq α
l₁ l₂ t₁ : List α
a : α
l₁✝ l₂✝ : List α
a✝ : l₁✝ ~ l₂✝
ih : List.union l₁✝ t₁ ~ List.union l₂✝ t₁
⊢ List.insert a (List.union l₁✝ t₁) ~ List.insert a (List.union l₂✝ t₁)

tactic: apply perm_insert_swap
state_before: case swap
α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
l₁ l₂ t₁ : List α
x✝ y✝ : α
l✝ : List α
⊢ List.insert y✝ (List.insert x✝ (List.union l✝ t₁)) ~ List.insert x✝ (List.insert y✝ (List.union l✝ t₁))

tactic: exact ih_1.trans ih_2
state_before: case trans
α : Type uu
β : Type vv
l₁✝¹ l₂✝¹ : List α
inst✝ : DecidableEq α
l₁ l₂ t₁ l₁✝ l₂✝ l₃✝ : List α
a✝¹ : l₁✝ ~ l₂✝
a✝ : l₂✝ ~ l₃✝
ih_1 : List.union l₁✝ t₁ ~ List.union l₂✝ t₁
ih_2 : List.union l₂✝ t₁ ~ List.union l₃✝ t₁
⊢ List.union l₁✝ t₁ ~ List.union l₃✝ t₁
Theorem: String.get_cons_addChar
File: Std/Data/String/Lemmas.lean

tactic: simp [get, utf8GetAux, Pos.zero_ne_addChar, utf8GetAux_addChar_right_cancel]
state_before: c : Char
cs : List Char
i : Pos
⊢ get { data := c :: cs } (i + c) = get { data := cs } i
Theorem: CircleDeg1Lift.tendsto_atTop
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simpa [sub_eq_add_neg] using tendsto_atTop_add_const_right _ _ tendsto_id
state_before: f g : CircleDeg1Lift
⊢ Tendsto (fun x => x - 1) atTop atTop