tasksource/leandojo huggingface dataset:
Theorem: Associates.dvd_of_mem_factors'
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: haveI := Classical.decEq (Associates α)
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
a : α
p : Associates α
hp : Irreducible p
hz : a ≠ 0
h_mem : { val := p, property := hp } ∈ factors' a
⊢ p ∣ Associates.mk a

tactic: apply dvd_of_mem_factors (hp := hp)
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
a : α
p : Associates α
hp : Irreducible p
hz : a ≠ 0
h_mem : { val := p, property := hp } ∈ factors' a
this : DecidableEq (Associates α)
⊢ p ∣ Associates.mk a

tactic: rw [factors_mk _ hz]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
a : α
p : Associates α
hp : Irreducible p
hz : a ≠ 0
h_mem : { val := p, property := hp } ∈ factors' a
this : DecidableEq (Associates α)
⊢ p ∈ factors (Associates.mk a)

tactic: apply mem_factorSet_some.2 h_mem
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
a : α
p : Associates α
hp : Irreducible p
hz : a ≠ 0
h_mem : { val := p, property := hp } ∈ factors' a
this : DecidableEq (Associates α)
⊢ p ∈ ↑(factors' a)
Theorem: ProbabilityTheory.kernel.restrict_apply'
File: Mathlib/Probability/Kernel/Basic.lean

tactic: rw [restrict_apply κ hs a, Measure.restrict_apply ht]
state_before: α : Type u_1
β : Type u_2
ι : Type ?u.1443714
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : { x // x ∈ kernel α β }
s t : Set β
κ : { x // x ∈ kernel α β }
hs : MeasurableSet s
a : α
ht : MeasurableSet t
⊢ ↑↑(↑(kernel.restrict κ hs) a) t = ↑↑(↑κ a) (t ∩ s)
Theorem: InnerProductSpace.Core.inner_mul_symm_re_eq_norm
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← inner_conj_symm, mul_comm]
state_before: 𝕜 : Type u_1
E : Type ?u.606441
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y : F
⊢ ↑re (inner x y * inner y x) = ‖inner x y * inner y x‖

tactic: exact re_eq_norm_of_mul_conj (inner y x)
state_before: 𝕜 : Type u_1
E : Type ?u.606441
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y : F
⊢ ↑re (inner y x * ↑(starRingEnd 𝕜) (inner y x)) = ‖inner y x * ↑(starRingEnd 𝕜) (inner y x)‖
Theorem: Trivialization.map_proj_nhds
File: Mathlib/Topology/FiberBundle/Trivialization.lean

tactic: rw [← e.coe_fst ex, ← map_congr (e.coe_fst_eventuallyEq_proj ex), ← map_map, ← e.coe_coe,
  e.map_nhds_eq ex, map_fst_nhds]
state_before: ι : Type ?u.29960
B : Type u_2
F : Type u_3
E : B → Type ?u.29971
Z : Type u_1
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace E)
e : Trivialization F proj
x : Z
ex : x ∈ e.source
⊢ map proj (𝓝 x) = 𝓝 (proj x)
Theorem: Matrix.conjTranspose_zpow
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

tactic: rw [zpow_ofNat, zpow_ofNat, conjTranspose_pow]
state_before: n' : Type u_2
inst✝³ : DecidableEq n'
inst✝² : Fintype n'
R : Type u_1
inst✝¹ : CommRing R
inst✝ : StarRing R
A : M
n : ℕ
⊢ (A ^ ↑n)ᴴ = Aᴴ ^ ↑n

tactic: rw [zpow_negSucc, zpow_negSucc, conjTranspose_nonsing_inv, conjTranspose_pow]
state_before: n' : Type u_2
inst✝³ : DecidableEq n'
inst✝² : Fintype n'
R : Type u_1
inst✝¹ : CommRing R
inst✝ : StarRing R
A : M
n : ℕ
⊢ (A ^ -[n+1])ᴴ = Aᴴ ^ -[n+1]
Theorem: CategoryTheory.μ_naturalityₗ
File: Mathlib/CategoryTheory/Monoidal/End.lean

tactic: rw [← μ_naturality₂ F f (𝟙 n) X]
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m n m' : M
f : m ⟶ m'
X : C
⊢ (F.obj n).map ((F.map f).app X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m' n).app X =
    (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m n).app X ≫ (F.map (f ⊗ 𝟙 n)).app X

tactic: simp
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m n m' : M
f : m ⟶ m'
X : C
⊢ (F.obj n).map ((F.map f).app X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m' n).app X =
    (F.map (𝟙 n)).app ((F.obj m).obj X) ≫
      (F.obj n).map ((F.map f).app X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor m' n).app X
Theorem: IsCoprime.mul_add_right_left
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: rw [add_comm]
state_before: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime (z * y + x) y

tactic: exact h.add_mul_right_left z
state_before: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime (x + z * y) y
Theorem: VectorBundleCore.inCoordinates_eq
File: Mathlib/Topology/VectorBundle/Basic.lean

tactic: simp_rw [inCoordinates, Z'.trivializationAt_continuousLinearMapAt hy,
  Z.trivializationAt_symmL hx]
state_before: R : Type ?u.536498
B : Type u_4
F : Type u_5
E : B → Type ?u.536509
inst✝²² : NontriviallyNormedField R
inst✝²¹ : (x : B) → AddCommMonoid (E x)
inst✝²⁰ : (x : B) → Module R (E x)
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace R F
inst✝¹⁷ : TopologicalSpace B
inst✝¹⁶ : (x : B) → TopologicalSpace (E x)
𝕜₁ : Type u_3
𝕜₂ : Type u_6
inst✝¹⁵ : NontriviallyNormedField 𝕜₁
inst✝¹⁴ : NontriviallyNormedField 𝕜₂
σ : 𝕜₁ →+* 𝕜₂
B' : Type u_7
inst✝¹³ : TopologicalSpace B'
inst✝¹² : NormedSpace 𝕜₁ F
inst✝¹¹ : (x : B) → Module 𝕜₁ (E x)
inst✝¹⁰ : TopologicalSpace (TotalSpace E)
F' : Type u_8
inst✝⁹ : NormedAddCommGroup F'
inst✝⁸ : NormedSpace 𝕜₂ F'
E' : B' → Type ?u.537479
inst✝⁷ : (x : B') → AddCommMonoid (E' x)
inst✝⁶ : (x : B') → Module 𝕜₂ (E' x)
inst✝⁵ : TopologicalSpace (TotalSpace E')
inst✝⁴ : FiberBundle F E
inst✝³ : VectorBundle 𝕜₁ F E
inst✝² : (x : B') → TopologicalSpace (E' x)
inst✝¹ : FiberBundle F' E'
inst✝ : VectorBundle 𝕜₂ F' E'
ι : Type u_1
ι' : Type u_2
Z : VectorBundleCore 𝕜₁ B F ι
Z' : VectorBundleCore 𝕜₂ B' F' ι'
x₀ x : B
y₀ y : B'
ϕ : F →SL[σ] F'
hx : x ∈ VectorBundleCore.baseSet Z (VectorBundleCore.indexAt Z x₀)
hy : y ∈ VectorBundleCore.baseSet Z' (VectorBundleCore.indexAt Z' y₀)
⊢ inCoordinates F (VectorBundleCore.Fiber Z) F' (VectorBundleCore.Fiber Z') x₀ x y₀ y ϕ =
    comp (VectorBundleCore.coordChange Z' (VectorBundleCore.indexAt Z' y) (VectorBundleCore.indexAt Z' y₀) y)
      (comp ϕ (VectorBundleCore.coordChange Z (VectorBundleCore.indexAt Z x₀) (VectorBundleCore.indexAt Z x) x))
Theorem: SimpleGraph.Walk.IsTrail.of_cons
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp [isTrail_def]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
h : Adj G u v
p : Walk G v w
⊢ IsTrail (cons h p) → IsTrail p
Theorem: CategoryTheory.Limits.IsZero.of_mono
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

tactic: have hf := i.eq_zero_of_tgt f
state_before: C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : Mono f
i : IsZero Y
⊢ IsZero X

tactic: subst hf
state_before: C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : Mono f
i : IsZero Y
hf : f = 0
⊢ IsZero X

tactic: exact IsZero.of_mono_zero X Y
state_before: C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
X Y : C
i : IsZero Y
inst✝ : Mono 0
⊢ IsZero X
Theorem: pochhammer_map
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: induction' n with n ih
state_before: S : Type u
inst✝¹ : Semiring S
T : Type v
inst✝ : Semiring T
f : S →+* T
n : ℕ
⊢ map f (pochhammer S n) = pochhammer T n

tactic: simp
state_before: case zero
S : Type u
inst✝¹ : Semiring S
T : Type v
inst✝ : Semiring T
f : S →+* T
⊢ map f (pochhammer S Nat.zero) = pochhammer T Nat.zero

tactic: simp [ih, pochhammer_succ_left, map_comp]
state_before: case succ
S : Type u
inst✝¹ : Semiring S
T : Type v
inst✝ : Semiring T
f : S →+* T
n : ℕ
ih : map f (pochhammer S n) = pochhammer T n
⊢ map f (pochhammer S (Nat.succ n)) = pochhammer T (Nat.succ n)
Theorem: Int.sq_mod_four_eq_one_of_odd
File: Mathlib/NumberTheory/Multiplicity.lean

tactic: intro hx
state_before: R : Type ?u.849581
n : ℕ
x : ℤ
⊢ Odd x → x ^ 2 % 4 = 1

tactic: unfold Odd at hx
state_before: R : Type ?u.849581
n : ℕ
x : ℤ
hx : Odd x
⊢ x ^ 2 % 4 = 1

tactic: rcases hx with ⟨_, rfl⟩
state_before: R : Type ?u.849581
n : ℕ
x : ℤ
hx : ∃ k, x = 2 * k + 1
⊢ x ^ 2 % 4 = 1

tactic: ring_nf
state_before: case intro
R : Type ?u.849581
n : ℕ
w✝ : ℤ
⊢ (2 * w✝ + 1) ^ 2 % 4 = 1

tactic: rw [add_assoc, ← add_mul, Int.add_mul_emod_self]
state_before: case intro
R : Type ?u.849581
n : ℕ
w✝ : ℤ
⊢ (1 + w✝ * 4 + w✝ ^ 2 * 4) % 4 = 1

tactic: norm_num
state_before: case intro
R : Type ?u.849581
n : ℕ
w✝ : ℤ
⊢ 1 % 4 = 1
Theorem: ENNReal.le_toReal_sub
File: Mathlib/Data/Real/ENNReal.lean

tactic: lift b to ℝ≥0 using hb
state_before: α : Type ?u.791480
β : Type ?u.791483
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a b : ℝ≥0∞
hb : b ≠ ⊤
⊢ ENNReal.toReal a - ENNReal.toReal b ≤ ENNReal.toReal (a - b)

tactic: induction a using recTopCoe
state_before: case intro
α : Type ?u.791480
β : Type ?u.791483
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
b : ℝ≥0
⊢ ENNReal.toReal a - ENNReal.toReal ↑b ≤ ENNReal.toReal (a - ↑b)

tactic: simp
state_before: case intro.top
α : Type ?u.791480
β : Type ?u.791483
a b✝ c d : ℝ≥0∞
r p q b : ℝ≥0
⊢ ENNReal.toReal ⊤ - ENNReal.toReal ↑b ≤ ENNReal.toReal (⊤ - ↑b)

tactic: simp only [← coe_sub, NNReal.sub_def, Real.coe_toNNReal', coe_toReal]
state_before: case intro.coe
α : Type ?u.791480
β : Type ?u.791483
a b✝ c d : ℝ≥0∞
r p q b x✝ : ℝ≥0
⊢ ENNReal.toReal ↑x✝ - ENNReal.toReal ↑b ≤ ENNReal.toReal (↑x✝ - ↑b)

tactic: exact le_max_left _ _
state_before: case intro.coe
α : Type ?u.791480
β : Type ?u.791483
a b✝ c d : ℝ≥0∞
r p q b x✝ : ℝ≥0
⊢ ↑x✝ - ↑b ≤ max (↑x✝ - ↑b) 0
Theorem: Finmap.mem_erase
File: Mathlib/Data/Finmap.lean

tactic: simp
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a a' : α
s✝ : Finmap β
s : AList β
⊢ a' ∈ erase a ⟦s⟧ ↔ a' ≠ a ∧ a' ∈ ⟦s⟧
Theorem: MeasureTheory.ae_le_trim_of_stronglyMeasurable
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: rwa [EventuallyLE, @ae_iff _ m, trim_measurableSet_eq hm _]
state_before: α : Type ?u.1731454
E : Type ?u.1731457
F : Type ?u.1731460
𝕜 : Type ?u.1731463
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace ℝ E
inst✝¹¹ : CompleteSpace E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : SMulCommClass ℝ 𝕜 E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : CompleteSpace F
H : Type ?u.1734134
β : Type u_2
γ : Type u_1
inst✝⁴ : NormedAddCommGroup H
m m0 : MeasurableSpace β
μ : Measure β
inst✝³ : LinearOrder γ
inst✝² : TopologicalSpace γ
inst✝¹ : OrderClosedTopology γ
inst✝ : PseudoMetrizableSpace γ
hm : m ≤ m0
f g : β → γ
hf : StronglyMeasurable f
hg : StronglyMeasurable g
hfg : f ≤ᵐ[μ] g
⊢ f ≤ᵐ[Measure.trim μ hm] g

tactic: exact (hf.measurableSet_le hg).compl
state_before: α : Type ?u.1731454
E : Type ?u.1731457
F : Type ?u.1731460
𝕜 : Type ?u.1731463
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace ℝ E
inst✝¹¹ : CompleteSpace E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : SMulCommClass ℝ 𝕜 E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : CompleteSpace F
H : Type ?u.1734134
β : Type u_2
γ : Type u_1
inst✝⁴ : NormedAddCommGroup H
m m0 : MeasurableSpace β
μ : Measure β
inst✝³ : LinearOrder γ
inst✝² : TopologicalSpace γ
inst✝¹ : OrderClosedTopology γ
inst✝ : PseudoMetrizableSpace γ
hm : m ≤ m0
f g : β → γ
hf : StronglyMeasurable f
hg : StronglyMeasurable g
hfg : f ≤ᵐ[μ] g
⊢ MeasurableSet {a | ¬f a ≤ g a}
Theorem: LocalizedModule.divBy_mul_by
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: intro ⟨m, t⟩
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : { x // x ∈ S }
p : LocalizedModule S M
⊢ ∀ (a : M × { x // x ∈ S }),
    ↑(divBy s) (↑(↑(algebraMap R (Module.End R (LocalizedModule S M))) ↑s) (Quotient.mk (r.setoid S M) a)) =
      Quotient.mk (r.setoid S M) a

tactic: simp only [Module.algebraMap_end_apply, smul'_mk, divBy_apply]
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : { x // x ∈ S }
p : LocalizedModule S M
m : M
t : { x // x ∈ S }
⊢ ↑(divBy s) (↑(↑(algebraMap R (Module.End R (LocalizedModule S M))) ↑s) (Quotient.mk (r.setoid S M) (m, t))) =
    Quotient.mk (r.setoid S M) (m, t)

tactic: erw [LocalizedModule.liftOn_mk]
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : { x // x ∈ S }
p : LocalizedModule S M
m : M
t : { x // x ∈ S }
⊢ liftOn (↑s • Quotient.mk (r.setoid S M) (m, t)) (fun p => mk p.fst (s * p.snd))
      (_ :
        ∀ (x x_1 : M × { x // x ∈ S }),
          x ≈ x_1 → (fun p => mk p.fst (s * p.snd)) x = (fun p => mk p.fst (s * p.snd)) x_1) =
    Quotient.mk (r.setoid S M) (m, t)

tactic: simp only [one_mul]
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : { x // x ∈ S }
p : LocalizedModule S M
m : M
t : { x // x ∈ S }
⊢ mk ((↑(algebraMap R R) ↑s, 1).fst • (m, t).fst, (↑(algebraMap R R) ↑s, 1).snd * (m, t).snd).fst
      (s * ((↑(algebraMap R R) ↑s, 1).fst • (m, t).fst, (↑(algebraMap R R) ↑s, 1).snd * (m, t).snd).snd) =
    Quotient.mk (r.setoid S M) (m, t)

tactic: change mk (s • m) (s * t) = mk m t
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : { x // x ∈ S }
p : LocalizedModule S M
m : M
t : { x // x ∈ S }
⊢ mk (↑(algebraMap R R) ↑s • m) (s * t) = Quotient.mk (r.setoid S M) (m, t)

tactic: rw [mk_cancel_common_left s t]
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : { x // x ∈ S }
p : LocalizedModule S M
m : M
t : { x // x ∈ S }
⊢ mk (s • m) (s * t) = mk m t
Theorem: LieIdeal.comap_map_eq
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: rw [← LieSubmodule.coe_toSubmodule_eq_iff, comap_coeSubmodule, I.map_coeSubmodule f h,
  LieSubmodule.sup_coe_toSubmodule, f.ker_coeSubmodule, Submodule.comap_map_eq]
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
h : ↑(map f I) = ↑f '' ↑I
⊢ comap f (map f I) = I ⊔ LieHom.ker f
Theorem: Real.logb_lt_logb_iff
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [logb, logb, div_lt_div_right (log_pos hb)]
state_before: b x y : ℝ
hb : 1 < b
hx : 0 < x
hy : 0 < y
⊢ logb b x < logb b y ↔ x < y

tactic: exact log_lt_log_iff hx hy
state_before: b x y : ℝ
hb : 1 < b
hx : 0 < x
hy : 0 < y
⊢ log x < log y ↔ x < y
Theorem: MeasureTheory.Measure.add_haar_ball_center
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

tactic: rw [this, measure_preimage_add]
state_before: E✝ : Type ?u.1965249
inst✝¹² : NormedAddCommGroup E✝
inst✝¹¹ : NormedSpace ℝ E✝
inst✝¹⁰ : MeasurableSpace E✝
inst✝⁹ : BorelSpace E✝
inst✝⁸ : FiniteDimensional ℝ E✝
μ✝ : Measure E✝
inst✝⁷ : IsAddHaarMeasure μ✝
F : Type ?u.1965918
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : CompleteSpace F
s : Set E✝
E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : IsAddHaarMeasure μ
x : E
r : ℝ
this : ball 0 r = (fun x x_1 => x + x_1) x ⁻¹' ball x r
⊢ ↑↑μ (ball x r) = ↑↑μ (ball 0 r)

tactic: simp [preimage_add_ball]
state_before: E✝ : Type ?u.1965249
inst✝¹² : NormedAddCommGroup E✝
inst✝¹¹ : NormedSpace ℝ E✝
inst✝¹⁰ : MeasurableSpace E✝
inst✝⁹ : BorelSpace E✝
inst✝⁸ : FiniteDimensional ℝ E✝
μ✝ : Measure E✝
inst✝⁷ : IsAddHaarMeasure μ✝
F : Type ?u.1965918
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : CompleteSpace F
s : Set E✝
E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : IsAddHaarMeasure μ
x : E
r : ℝ
⊢ ball 0 r = (fun x x_1 => x + x_1) x ⁻¹' ball x r
Theorem: comap_upperCentralSeries_quotient_center
File: Mathlib/GroupTheory/Nilpotent.lean

tactic: induction' n with n ih
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
n : ℕ
⊢ comap (mk' (center G)) (upperCentralSeries (G ⧸ center G) n) = upperCentralSeries G (Nat.succ n)

tactic: simp only [Nat.zero_eq, upperCentralSeries_zero, MonoidHom.comap_bot, ker_mk',
  (upperCentralSeries_one G).symm]
state_before: case zero
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
⊢ comap (mk' (center G)) (upperCentralSeries (G ⧸ center G) Nat.zero) = upperCentralSeries G (Nat.succ Nat.zero)

tactic: let Hn := upperCentralSeries (G ⧸ center G) n
state_before: case succ
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
n : ℕ
ih : comap (mk' (center G)) (upperCentralSeries (G ⧸ center G) n) = upperCentralSeries G (Nat.succ n)
⊢ comap (mk' (center G)) (upperCentralSeries (G ⧸ center G) (Nat.succ n)) = upperCentralSeries G (Nat.succ (Nat.succ n))

tactic: calc
  comap (mk' (center G)) (upperCentralSeriesStep Hn) =
      comap (mk' (center G)) (comap (mk' Hn) (center ((G ⧸ center G) ⧸ Hn))) :=
    by rw [upperCentralSeriesStep_eq_comap_center]
  _ = comap (mk' (comap (mk' (center G)) Hn)) (center (G ⧸ comap (mk' (center G)) Hn)) :=
    QuotientGroup.comap_comap_center
  _ = comap (mk' (upperCentralSeries G n.succ)) (center (G ⧸ upperCentralSeries G n.succ)) :=
    (comap_center_subst ih)
  _ = upperCentralSeriesStep (upperCentralSeries G n.succ) :=
    symm (upperCentralSeriesStep_eq_comap_center _)
state_before: case succ
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
n : ℕ
ih : comap (mk' (center G)) (upperCentralSeries (G ⧸ center G) n) = upperCentralSeries G (Nat.succ n)
Hn : Subgroup (G ⧸ center G) := upperCentralSeries (G ⧸ center G) n
⊢ comap (mk' (center G)) (upperCentralSeries (G ⧸ center G) (Nat.succ n)) = upperCentralSeries G (Nat.succ (Nat.succ n))

tactic: rw [upperCentralSeriesStep_eq_comap_center]
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
n : ℕ
ih : comap (mk' (center G)) (upperCentralSeries (G ⧸ center G) n) = upperCentralSeries G (Nat.succ n)
Hn : Subgroup (G ⧸ center G) := upperCentralSeries (G ⧸ center G) n
⊢ comap (mk' (center G)) (upperCentralSeriesStep Hn) =
    comap (mk' (center G)) (comap (mk' Hn) (center ((G ⧸ center G) ⧸ Hn)))
Theorem: hasCompactMulSupport_comp_left
File: Mathlib/Topology/Support.lean

tactic: simp_rw [hasCompactMulSupport_def, mulSupport_comp_eq g (@hg) f]
state_before: X : Type ?u.14903
α : Type u_3
α' : Type ?u.14909
β : Type u_2
γ : Type u_1
δ : Type ?u.14918
M : Type ?u.14921
E : Type ?u.14924
R : Type ?u.14927
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace α'
inst✝² : One β
inst✝¹ : One γ
inst✝ : One δ
g : β → γ
f : α → β
f₂ : α → γ
m : β → γ → δ
x : α
hg : ∀ {x : β}, g x = 1 ↔ x = 1
⊢ HasCompactMulSupport (g ∘ f) ↔ HasCompactMulSupport f
Theorem: Set.mem_iff_boolIndicator
File: Mathlib/Data/Set/BoolIndicator.lean

tactic: unfold boolIndicator
state_before: α : Type u_1
s : Set α
x : α
⊢ x ∈ s ↔ boolIndicator s x = true

tactic: split_ifs with h <;> simp [h]
state_before: α : Type u_1
s : Set α
x : α
⊢ x ∈ s ↔ (if x ∈ s then true else false) = true
Theorem: OrthonormalBasis.orientation_adjustToOrientation
File: Mathlib/Analysis/InnerProductSpace/Orientation.lean

tactic: rw [e.toBasis_adjustToOrientation]
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
ne : Nonempty ι
e f : OrthonormalBasis ι ℝ E
x : Orientation ℝ E ι
⊢ Basis.orientation (OrthonormalBasis.toBasis (adjustToOrientation e x)) = x

tactic: exact e.toBasis.orientation_adjustToOrientation x
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
ne : Nonempty ι
e f : OrthonormalBasis ι ℝ E
x : Orientation ℝ E ι
⊢ Basis.orientation (Basis.adjustToOrientation (OrthonormalBasis.toBasis e) x) = x
Theorem: Fin.coe_castPred
File: Mathlib/Data/Fin/Basic.lean

tactic: rcases a with ⟨a, ha⟩
state_before: n✝ m n : ℕ
a : Fin (n + 2)
hx : a < last (n + 1)
⊢ ↑(castPred a) = ↑a

tactic: rw [castPred_mk]
state_before: case mk
n✝ m n a : ℕ
ha : a < n + 2
hx : { val := a, isLt := ha } < last (n + 1)
⊢ ↑(castPred { val := a, isLt := ha }) = ↑{ val := a, isLt := ha }

tactic: exact hx
state_before: case mk.h
n✝ m n a : ℕ
ha : a < n + 2
hx : { val := a, isLt := ha } < last (n + 1)
⊢ a < n + 1
Theorem: HasFTaylorSeriesUpToOn.restrictScalars
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: simpa only using (ContinuousMultilinearMap.restrictScalarsLinear 𝕜).hasFDerivAt.comp_hasFDerivWithinAt x <|
    (h.fderivWithin m hm x hx).restrictScalars 𝕜
state_before: 𝕜 : Type u_2
inst✝¹⁶ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹⁵ : NormedAddCommGroup D
inst✝¹⁴ : NormedSpace 𝕜 D
E : Type uE
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
F : Type uF
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
G : Type uG
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
X : Type ?u.3124593
inst✝⁷ : NormedAddCommGroup X
inst✝⁶ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x✝ x₀ : E
c : F
b : E × F → G
m✝ n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
𝕜' : Type u_1
inst✝⁵ : NontriviallyNormedField 𝕜'
inst✝⁴ : NormedAlgebra 𝕜 𝕜'
inst✝³ : NormedSpace 𝕜' E
inst✝² : IsScalarTower 𝕜 𝕜' E
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
p' : E → FormalMultilinearSeries 𝕜' E F
h : HasFTaylorSeriesUpToOn n f p' s
m : ℕ
hm : ↑m < n
x : E
hx : x ∈ s
⊢ HasFDerivWithinAt (fun x => FormalMultilinearSeries.restrictScalars 𝕜 (p' x) m)
    (ContinuousMultilinearMap.curryLeft (FormalMultilinearSeries.restrictScalars 𝕜 (p' x) (Nat.succ m))) s x
Theorem: Lagrange.interpolate_empty
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rw [interpolate_apply, sum_empty]
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
⊢ ↑(interpolate ∅ v) r = 0
Theorem: List.get?_set
File: Std/Data/List/Lemmas.lean

tactic: by_cases m = n <;> simp [*, get?_set_eq, get?_set_ne]
state_before: α : Type u_1
a : α
m n : Nat
l : List α
⊢ get? (set l m a) n = if m = n then (fun x => a) <$> get? l n else get? l n
Theorem: Stream'.eq_or_mem_of_mem_cons
File: Mathlib/Data/Stream/Init.lean

tactic: cases' n with n'
state_before: α : Type u
β : Type v
δ : Type w
a b : α
s : Stream' α
x✝ : a ∈ b :: s
n : ℕ
h : (fun b => a = b) (nth (b :: s) n)
⊢ a = b ∨ a ∈ s

tactic: left
state_before: case zero
α : Type u
β : Type v
δ : Type w
a b : α
s : Stream' α
x✝ : a ∈ b :: s
h : a = nth (b :: s) zero
⊢ a = b ∨ a ∈ s

tactic: exact h
state_before: case zero.h
α : Type u
β : Type v
δ : Type w
a b : α
s : Stream' α
x✝ : a ∈ b :: s
h : a = nth (b :: s) zero
⊢ a = b

tactic: right
state_before: case succ
α : Type u
β : Type v
δ : Type w
a b : α
s : Stream' α
x✝ : a ∈ b :: s
n' : ℕ
h : a = nth (b :: s) (succ n')
⊢ a = b ∨ a ∈ s

tactic: rw [nth_succ, tail_cons] at h
state_before: case succ.h
α : Type u
β : Type v
δ : Type w
a b : α
s : Stream' α
x✝ : a ∈ b :: s
n' : ℕ
h : a = nth (b :: s) (succ n')
⊢ a ∈ s

tactic: exact ⟨n', h⟩
state_before: case succ.h
α : Type u
β : Type v
δ : Type w
a b : α
s : Stream' α
x✝ : a ∈ b :: s
n' : ℕ
h : a = nth s n'
⊢ a ∈ s