tasksource/leandojo huggingface dataset:
Theorem: Complex.tendsto_limUnder_of_differentiable_on_punctured_nhds_of_isLittleO
File: Mathlib/Analysis/Complex/RemovableSingularity.lean

tactic: rw [eventually_nhdsWithin_iff] at hd
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
hd : ∀ᶠ (z : ℂ) in 𝓝[{c}ᶜ] c, DifferentiableAt ℂ f z
ho : (fun z => f z - f c) =o[𝓝[{c}ᶜ] c] fun z => (z - c)⁻¹
⊢ Tendsto f (𝓝[{c}ᶜ] c) (𝓝 (limUnder (𝓝[{c}ᶜ] c) f))

tactic: have : DifferentiableOn ℂ f ({z | z ≠ c → DifferentiableAt ℂ f z} \ {c}) := fun z hz =>
  (hz.1 hz.2).differentiableWithinAt
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
hd : ∀ᶠ (x : ℂ) in 𝓝 c, x ∈ {c}ᶜ → DifferentiableAt ℂ f x
ho : (fun z => f z - f c) =o[𝓝[{c}ᶜ] c] fun z => (z - c)⁻¹
⊢ Tendsto f (𝓝[{c}ᶜ] c) (𝓝 (limUnder (𝓝[{c}ᶜ] c) f))

tactic: have H := differentiableOn_update_limUnder_of_isLittleO hd this ho
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
hd : ∀ᶠ (x : ℂ) in 𝓝 c, x ∈ {c}ᶜ → DifferentiableAt ℂ f x
ho : (fun z => f z - f c) =o[𝓝[{c}ᶜ] c] fun z => (z - c)⁻¹
this : DifferentiableOn ℂ f ({z | z ≠ c → DifferentiableAt ℂ f z} \ {c})
⊢ Tendsto f (𝓝[{c}ᶜ] c) (𝓝 (limUnder (𝓝[{c}ᶜ] c) f))

tactic: exact continuousAt_update_same.1 (H.differentiableAt hd).continuousAt
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
hd : ∀ᶠ (x : ℂ) in 𝓝 c, x ∈ {c}ᶜ → DifferentiableAt ℂ f x
ho : (fun z => f z - f c) =o[𝓝[{c}ᶜ] c] fun z => (z - c)⁻¹
this : DifferentiableOn ℂ f ({z | z ≠ c → DifferentiableAt ℂ f z} \ {c})
H : DifferentiableOn ℂ (update f c (limUnder (𝓝[{c}ᶜ] c) f)) {x | (fun x => x ∈ {c}ᶜ → DifferentiableAt ℂ f x) x}
⊢ Tendsto f (𝓝[{c}ᶜ] c) (𝓝 (limUnder (𝓝[{c}ᶜ] c) f))
Theorem: Set.infinite_union
File: Mathlib/Data/Set/Finite.lean

tactic: simp only [Set.Infinite, finite_union, not_and_or]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
⊢ Set.Infinite (s ∪ t) ↔ Set.Infinite s ∨ Set.Infinite t
Theorem: Nat.Prime.factorization_pow
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: simp [hp]
state_before: p k : ℕ
hp : Prime p
⊢ Nat.factorization (p ^ k) = single p k
Theorem: Finsupp.total_apply_of_mem_supported
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: rw [not_mem_support_iff.1 hxg, zero_smul]
state_before: α : Type u_1
M : Type u_3
N : Type ?u.286502
P : Type ?u.286505
R : Type u_2
S : Type ?u.286511
inst✝¹² : Semiring R
inst✝¹¹ : Semiring S
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
inst✝⁸ : AddCommMonoid N
inst✝⁷ : Module R N
inst✝⁶ : AddCommMonoid P
inst✝⁵ : Module R P
α' : Type ?u.286603
M' : Type ?u.286606
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M'
inst✝² : AddCommMonoid M
inst✝¹ : Module R M'
inst✝ : Module R M
v : α → M
v' : α' → M'
l : α →₀ R
s : Finset α
hs : l ∈ supported R R ↑s
x : α
x✝ : x ∈ s
hxg : ¬x ∈ l.support
⊢ ↑l x • v x = 0
Theorem: ContinuousMap.abs_mem_subalgebra_closure
File: Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean

tactic: let f' := attachBound (f : C(X, ℝ))
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
f : { x // x ∈ A }
⊢ abs ↑f ∈ Subalgebra.topologicalClosure A

tactic: let abs : C(Set.Icc (-‖f‖) ‖f‖, ℝ) := { toFun := fun x : Set.Icc (-‖f‖) ‖f‖ => |(x : ℝ)| }
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
f : { x // x ∈ A }
f' : C(X, ↑(Set.Icc (-‖↑f‖) ‖↑f‖)) := attachBound ↑f
⊢ abs ↑f ∈ Subalgebra.topologicalClosure A

tactic: change abs.comp f' ∈ A.topologicalClosure
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
f : { x // x ∈ A }
f' : C(X, ↑(Set.Icc (-‖↑f‖) ‖↑f‖)) := attachBound ↑f
abs : C(↑(Set.Icc (-‖f‖) ‖f‖), ℝ) := mk fun x => Abs.abs ↑x
⊢ ContinuousMap.abs ↑f ∈ Subalgebra.topologicalClosure A

tactic: apply comp_attachBound_mem_closure
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
f : { x // x ∈ A }
f' : C(X, ↑(Set.Icc (-‖↑f‖) ‖↑f‖)) := attachBound ↑f
abs : C(↑(Set.Icc (-‖f‖) ‖f‖), ℝ) := mk fun x => Abs.abs ↑x
⊢ comp abs f' ∈ Subalgebra.topologicalClosure A
Theorem: Asymptotics.superpolynomialDecay_const_mul_iff
File: Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean

tactic: simp [← mul_assoc, inv_mul_cancel hc0]
state_before: α : Type u_2
β : Type u_1
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : Field β
inst✝ : ContinuousMul β
c : β
hc0 : c ≠ 0
h : SuperpolynomialDecay l k fun n => c * f n
x : α
⊢ c⁻¹ * (c * f x) = f x
Theorem: map_div'
File: Mathlib/Algebra/Hom/Group.lean

tactic: rw [div_eq_mul_inv, div_eq_mul_inv, map_mul, hf]
state_before: α : Type ?u.45321
β : Type ?u.45324
M : Type ?u.45327
N : Type ?u.45330
P : Type ?u.45333
G : Type u_1
H : Type u_2
F : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : DivInvMonoid G
inst✝¹ : DivInvMonoid H
inst✝ : MonoidHomClass F G H
f : F
hf : ∀ (a : G), ↑f a⁻¹ = (↑f a)⁻¹
a b : G
⊢ ↑f (a / b) = ↑f a / ↑f b
Theorem: Subgroup.comap_map_eq_self
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: rwa [comap_map_eq, sup_eq_left]
state_before: G : Type u_1
G' : Type ?u.582453
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.582462
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f✝ f : G →* N
H : Subgroup G
h : ker f ≤ H
⊢ comap f (map f H) = H
Theorem: Basis.toMatrix_map_vecMul
File: Mathlib/LinearAlgebra/Matrix/Basis.lean

tactic: ext i
state_before: ι : Type u_3
ι' : Type u_4
κ : Type ?u.263788
κ' : Type ?u.263791
R : Type u_2
M : Type ?u.263797
inst✝⁸ : CommSemiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
R₂ : Type ?u.263984
M₂ : Type ?u.263987
inst✝⁵ : CommRing R₂
inst✝⁴ : AddCommGroup M₂
inst✝³ : Module R₂ M₂
e : Basis ι R M
v✝ : ι' → M
i : ι
j : ι'
S : Type u_1
inst✝² : Ring S
inst✝¹ : Algebra R S
inst✝ : Fintype ι
b : Basis ι R S
v : ι' → S
⊢ vecMul (↑b) (Matrix.map (toMatrix b v) ↑(algebraMap R S)) = v

tactic: simp_rw [vecMul, dotProduct, Matrix.map_apply, ← Algebra.commutes, ← Algebra.smul_def,
  sum_toMatrix_smul_self]
state_before: case h
ι : Type u_3
ι' : Type u_4
κ : Type ?u.263788
κ' : Type ?u.263791
R : Type u_2
M : Type ?u.263797
inst✝⁸ : CommSemiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
R₂ : Type ?u.263984
M₂ : Type ?u.263987
inst✝⁵ : CommRing R₂
inst✝⁴ : AddCommGroup M₂
inst✝³ : Module R₂ M₂
e : Basis ι R M
v✝ : ι' → M
i✝ : ι
j : ι'
S : Type u_1
inst✝² : Ring S
inst✝¹ : Algebra R S
inst✝ : Fintype ι
b : Basis ι R S
v : ι' → S
i : ι'
⊢ vecMul (↑b) (Matrix.map (toMatrix b v) ↑(algebraMap R S)) i = v i
Theorem: Polynomial.normUnit_content
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: by_cases hp0 : p.content = 0
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
⊢ normUnit (content p) = 1

tactic: . simp [hp0]
state_before: case pos
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp0 : content p = 0
⊢ normUnit (content p) = 1

case neg
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp0 : ¬content p = 0
⊢ normUnit (content p) = 1

tactic: . ext
  apply mul_left_cancel₀ hp0
  erw [← normalize_apply, normalize_content, mul_one]
state_before: case neg
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp0 : ¬content p = 0
⊢ normUnit (content p) = 1

tactic: simp [hp0]
state_before: case pos
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp0 : content p = 0
⊢ normUnit (content p) = 1

tactic: ext
state_before: case neg
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp0 : ¬content p = 0
⊢ normUnit (content p) = 1

tactic: apply mul_left_cancel₀ hp0
state_before: case neg.a
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp0 : ¬content p = 0
⊢ ↑(normUnit (content p)) = ↑1

tactic: erw [← normalize_apply, normalize_content, mul_one]
state_before: case neg.a
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp0 : ¬content p = 0
⊢ content p * ↑(normUnit (content p)) = content p * ↑1
Theorem: InnerProductSpace.Core.inner_re_symm
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← inner_conj_symm, conj_re]
state_before: 𝕜 : Type u_1
E : Type ?u.367192
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y : F
⊢ ↑re (inner x y) = ↑re (inner y x)
Theorem: exists_nat_pow_near
File: Mathlib/Algebra/Order/Archimedean.lean

tactic: have h : ∃ n : ℕ, x < y ^ n := pow_unbounded_of_one_lt _ hy
state_before: α : Type u_1
inst✝¹ : LinearOrderedRing α
inst✝ : Archimedean α
x y : α
hx : 1 ≤ x
hy : 1 < y
⊢ ∃ n, y ^ n ≤ x ∧ x < y ^ (n + 1)

tactic: classical exact
    let n := Nat.find h
    have hn : x < y ^ n := Nat.find_spec h
    have hnp : 0 < n :=
      pos_iff_ne_zero.2 fun hn0 => by rw [hn0, pow_zero] at hn; exact not_le_of_gt hn hx
    have hnsp : Nat.pred n + 1 = n := Nat.succ_pred_eq_of_pos hnp
    have hltn : Nat.pred n < n := Nat.pred_lt (ne_of_gt hnp)
    ⟨Nat.pred n, le_of_not_lt (Nat.find_min h hltn), by rwa [hnsp]⟩
state_before: α : Type u_1
inst✝¹ : LinearOrderedRing α
inst✝ : Archimedean α
x y : α
hx : 1 ≤ x
hy : 1 < y
h : ∃ n, x < y ^ n
⊢ ∃ n, y ^ n ≤ x ∧ x < y ^ (n + 1)

tactic: exact
let n := Nat.find h
have hn : x < y ^ n := Nat.find_spec h
have hnp : 0 < n :=
pos_iff_ne_zero.2 fun hn0 => by rw [hn0, pow_zero] at hn; exact not_le_of_gt hn hx
have hnsp : Nat.pred n + 1 = n := Nat.succ_pred_eq_of_pos hnp
have hltn : Nat.pred n < n := Nat.pred_lt (ne_of_gt hnp)
⟨Nat.pred n, le_of_not_lt (Nat.find_min h hltn), by rwa [hnsp]⟩
state_before: α : Type u_1
inst✝¹ : LinearOrderedRing α
inst✝ : Archimedean α
x y : α
hx : 1 ≤ x
hy : 1 < y
h : ∃ n, x < y ^ n
⊢ ∃ n, y ^ n ≤ x ∧ x < y ^ (n + 1)

tactic: rw [hn0, pow_zero] at hn
state_before: α : Type u_1
inst✝¹ : LinearOrderedRing α
inst✝ : Archimedean α
x y : α
hx : 1 ≤ x
hy : 1 < y
h : ∃ n, x < y ^ n
n : ℕ := Nat.find h
hn : x < y ^ n
hn0 : n = 0
⊢ False

tactic: exact not_le_of_gt hn hx
state_before: α : Type u_1
inst✝¹ : LinearOrderedRing α
inst✝ : Archimedean α
x y : α
hx : 1 ≤ x
hy : 1 < y
h : ∃ n, x < y ^ n
n : ℕ := Nat.find h
hn : x < 1
hn0 : n = 0
⊢ False

tactic: rwa [hnsp]
state_before: α : Type u_1
inst✝¹ : LinearOrderedRing α
inst✝ : Archimedean α
x y : α
hx : 1 ≤ x
hy : 1 < y
h : ∃ n, x < y ^ n
n : ℕ := Nat.find h
hn : x < y ^ n
hnp : 0 < n
hnsp : Nat.pred n + 1 = n
hltn : Nat.pred n < n
⊢ x < y ^ (Nat.pred n + 1)
Theorem: Vector.scanl_singleton
File: Mathlib/Data/Vector/Basic.lean

tactic: rw [← cons_head_tail v]
state_before: n : ℕ
α : Type u_1
β : Type u_2
f : β → α → β
b : β
v✝ : Vector α n
v : Vector α 1
⊢ scanl f b v = b ::ᵥ f b (head v) ::ᵥ nil

tactic: simp only [scanl_cons, scanl_nil, head_cons, singleton_tail]
state_before: n : ℕ
α : Type u_1
β : Type u_2
f : β → α → β
b : β
v✝ : Vector α n
v : Vector α 1
⊢ scanl f b (head v ::ᵥ tail v) = b ::ᵥ f b (head (head v ::ᵥ tail v)) ::ᵥ nil
Theorem: Nat.card_fintypeIoc
File: Mathlib/Data/Nat/Interval.lean

tactic: rw [Fintype.card_ofFinset, card_Ioc]
state_before: a b c : ℕ
⊢ Fintype.card ↑(Set.Ioc a b) = b - a
Theorem: Set.Icc_bot_top
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.58216
inst✝¹ : PartialOrder α
inst✝ : BoundedOrder α
⊢ Icc ⊥ ⊤ = univ
Theorem: MeasureTheory.set_integral_const
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: rw [integral_const, Measure.restrict_apply_univ]
state_before: α : Type u_2
β : Type ?u.116823
E : Type u_1
F : Type ?u.116829
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
c : E
⊢ (∫ (x : α) in s, c ∂μ) = ENNReal.toReal (↑↑μ s) • c
Theorem: Polynomial.natDegree_cyclotomic'
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: rw [cyclotomic']
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
ζ : R
n : ℕ
h : IsPrimitiveRoot ζ n
⊢ natDegree (cyclotomic' n R) = Nat.totient n

tactic: rw [natDegree_prod (primitiveRoots n R) fun z : R => X - C z]
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
ζ : R
n : ℕ
h : IsPrimitiveRoot ζ n
⊢ natDegree (∏ μ in primitiveRoots n R, (X - ↑C μ)) = Nat.totient n

tactic: simp only [IsPrimitiveRoot.card_primitiveRoots h, mul_one, natDegree_X_sub_C, Nat.cast_id,
  Finset.sum_const, nsmul_eq_mul]
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
ζ : R
n : ℕ
h : IsPrimitiveRoot ζ n
⊢ ∑ i in primitiveRoots n R, natDegree (X - ↑C i) = Nat.totient n

R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
ζ : R
n : ℕ
h : IsPrimitiveRoot ζ n
⊢ ∀ (i : R), i ∈ primitiveRoots n R → X - ↑C i ≠ 0

tactic: intro z _
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
ζ : R
n : ℕ
h : IsPrimitiveRoot ζ n
⊢ ∀ (i : R), i ∈ primitiveRoots n R → X - ↑C i ≠ 0

tactic: exact X_sub_C_ne_zero z
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
ζ : R
n : ℕ
h : IsPrimitiveRoot ζ n
z : R
a✝ : z ∈ primitiveRoots n R
⊢ X - ↑C z ≠ 0
Theorem: CategoryTheory.Bicategory.hom_inv_whiskerLeft
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: rw [← whiskerLeft_comp, hom_inv_id, whiskerLeft_id]
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g h : b ⟶ c
η : g ≅ h
⊢ f ◁ η.hom ≫ f ◁ η.inv = 𝟙 (f ≫ g)
Theorem: StarSubalgebra.inf_toSubalgebra
File: Mathlib/Algebra/Star/Subalgebra.lean

tactic: ext
state_before: F : Type ?u.670328
R : Type u_1
A : Type u_2
B : Type ?u.670337
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
inst✝⁵ : StarRing A
inst✝⁴ : StarModule R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : StarRing B
inst✝ : StarModule R B
S T : StarSubalgebra R A
⊢ (S ⊓ T).toSubalgebra = S.toSubalgebra ⊓ T.toSubalgebra

tactic: simp
state_before: case h
F : Type ?u.670328
R : Type u_1
A : Type u_2
B : Type ?u.670337
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
inst✝⁵ : StarRing A
inst✝⁴ : StarModule R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : StarRing B
inst✝ : StarModule R B
S T : StarSubalgebra R A
x✝ : A
⊢ x✝ ∈ (S ⊓ T).toSubalgebra ↔ x✝ ∈ S.toSubalgebra ⊓ T.toSubalgebra
Theorem: IsLeftRegular.pow
File: Mathlib/Algebra/Regular/Pow.lean

tactic: simp only [IsLeftRegular, ← mul_left_iterate, rla.iterate n]
state_before: R : Type u_1
a b : R
inst✝ : Monoid R
n : ℕ
rla : IsLeftRegular a
⊢ IsLeftRegular (a ^ n)
Theorem: Asymptotics.SuperpolynomialDecay.add
File: Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean

tactic: simpa only [mul_add, add_zero, Pi.add_apply] using (hf z).add (hg z)
state_before: α : Type u_2
β : Type u_1
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : CommSemiring β
inst✝ : ContinuousAdd β
hf : SuperpolynomialDecay l k f
hg : SuperpolynomialDecay l k g
z : ℕ
⊢ Tendsto (fun a => k a ^ z * (f + g) a) l (𝓝 0)
Theorem: CategoryTheory.comp_ite
File: Mathlib/CategoryTheory/Category/Basic.lean

tactic: aesop
state_before: C : Type u
inst✝¹ : Category C
X✝ Y✝ Z✝ : C
P : Prop
inst✝ : Decidable P
X Y Z : C
f : X ⟶ Y
g g' : Y ⟶ Z
⊢ (f ≫ if P then g else g') = if P then f ≫ g else f ≫ g'
Theorem: Units.divp_sub
File: Mathlib/Algebra/Ring/Units.lean

tactic: simp only [divp, sub_mul, sub_right_inj]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : Ring α
a✝ b✝ a b : α
u : αˣ
⊢ a /ₚ u - b = (a - b * ↑u) /ₚ u

tactic: rw [mul_assoc, Units.mul_inv, mul_one]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : Ring α
a✝ b✝ a b : α
u : αˣ
⊢ b = b * ↑u * ↑u⁻¹
Theorem: LinearOrderedField.smul_Iio
File: Mathlib/Algebra/Order/Pointwise.lean

tactic: ext x
state_before: α : Type ?u.63203
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
⊢ r • Iio a = Iio (r • a)

tactic: simp only [mem_smul_set, smul_eq_mul, mem_Iio]
state_before: case h
α : Type ?u.63203
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
⊢ x ∈ r • Iio a ↔ x ∈ Iio (r • a)

tactic: constructor
state_before: case h
α : Type ?u.63203
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
⊢ (∃ y, y < a ∧ r * y = x) ↔ x < r * a

tactic: rintro ⟨a_w, a_h_left, rfl⟩
state_before: case h.mp
α : Type ?u.63203
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
⊢ (∃ y, y < a ∧ r * y = x) → x < r * a

tactic: exact (mul_lt_mul_left hr).mpr a_h_left
state_before: case h.mp.intro.intro
α : Type ?u.63203
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
a_w : K
a_h_left : a_w < a
⊢ r * a_w < r * a

tactic: rintro h
state_before: case h.mpr
α : Type ?u.63203
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
⊢ x < r * a → ∃ y, y < a ∧ r * y = x

tactic: use x / r
state_before: case h.mpr
α : Type ?u.63203
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
h : x < r * a
⊢ ∃ y, y < a ∧ r * y = x

tactic: constructor
state_before: case h.mpr
α : Type ?u.63203
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
h : x < r * a
⊢ x / r < a ∧ r * (x / r) = x

tactic: exact (div_lt_iff' hr).mpr h
state_before: case h.mpr.left
α : Type ?u.63203
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
h : x < r * a
⊢ x / r < a

case h.mpr.right
α : Type ?u.63203
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
h : x < r * a
⊢ r * (x / r) = x

tactic: exact mul_div_cancel' _ (ne_of_gt hr)
state_before: case h.mpr.right
α : Type ?u.63203
K : Type u_1
inst✝ : LinearOrderedField K
a b r : K
hr : 0 < r
x : K
h : x < r * a
⊢ r * (x / r) = x
Theorem: List.Pairwise.pmap
File: Mathlib/Data/List/Pairwise.lean

tactic: refine' (pairwise_pmap h).2 (Pairwise.imp_of_mem _ hl)
state_before: α : Type u_1
β : Type u_2
R S✝ T : α → α → Prop
a : α
l✝ l : List α
hl : Pairwise R l
p : α → Prop
f : (a : α) → p a → β
h : ∀ (x : α), x ∈ l → p x
S : β → β → Prop
hS : ∀ ⦃x : α⦄ (hx : p x) ⦃y : α⦄ (hy : p y), R x y → S (f x hx) (f y hy)
⊢ Pairwise S (List.pmap f l h)

tactic: intros
state_before: α : Type u_1
β : Type u_2
R S✝ T : α → α → Prop
a : α
l✝ l : List α
hl : Pairwise R l
p : α → Prop
f : (a : α) → p a → β
h : ∀ (x : α), x ∈ l → p x
S : β → β → Prop
hS : ∀ ⦃x : α⦄ (hx : p x) ⦃y : α⦄ (hy : p y), R x y → S (f x hx) (f y hy)
⊢ ∀ {a b : α}, a ∈ l → b ∈ l → R a b → ∀ (h₁ : p a) (h₂ : p b), S (f a h₁) (f b h₂)

tactic: apply hS
state_before: α : Type u_1
β : Type u_2
R S✝ T : α → α → Prop
a : α
l✝ l : List α
hl : Pairwise R l
p : α → Prop
f : (a : α) → p a → β
h : ∀ (x : α), x ∈ l → p x
S : β → β → Prop
hS : ∀ ⦃x : α⦄ (hx : p x) ⦃y : α⦄ (hy : p y), R x y → S (f x hx) (f y hy)
a✝³ b✝ : α
a✝² : a✝³ ∈ l
a✝¹ : b✝ ∈ l
a✝ : R a✝³ b✝
h₁✝ : p a✝³
h₂✝ : p b✝
⊢ S (f a✝³ h₁✝) (f b✝ h₂✝)

tactic: assumption
state_before: case a
α : Type u_1
β : Type u_2
R S✝ T : α → α → Prop
a : α
l✝ l : List α
hl : Pairwise R l
p : α → Prop
f : (a : α) → p a → β
h : ∀ (x : α), x ∈ l → p x
S : β → β → Prop
hS : ∀ ⦃x : α⦄ (hx : p x) ⦃y : α⦄ (hy : p y), R x y → S (f x hx) (f y hy)
a✝³ b✝ : α
a✝² : a✝³ ∈ l
a✝¹ : b✝ ∈ l
a✝ : R a✝³ b✝
h₁✝ : p a✝³
h₂✝ : p b✝
⊢ R a✝³ b✝
Theorem: TopCat.embedding_of_pullback_embeddings
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

tactic: convert H₂.comp (snd_embedding_of_left_embedding H₁ g)
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
H₁ : Embedding ((forget TopCat).map f)
H₂ : Embedding ((forget TopCat).map g)
⊢ Embedding ((forget TopCat).map (limit.π (cospan f g) WalkingCospan.one))

tactic: erw [← coe_comp]
state_before: case h.e'_5.h
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
H₁ : Embedding ((forget TopCat).map f)
H₂ : Embedding ((forget TopCat).map g)
e_2✝ : (forget TopCat).obj ((cospan f g).obj WalkingCospan.one) = (forget TopCat).obj S
⊢ (forget TopCat).map (limit.π (cospan f g) WalkingCospan.one) =
    (forget TopCat).map g ∘ (forget TopCat).map pullback.snd

tactic: congr
state_before: case h.e'_5.h
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
H₁ : Embedding ((forget TopCat).map f)
H₂ : Embedding ((forget TopCat).map g)
e_2✝ : (forget TopCat).obj ((cospan f g).obj WalkingCospan.one) = (forget TopCat).obj S
⊢ (forget TopCat).map (limit.π (cospan f g) WalkingCospan.one) = (forget TopCat).map (pullback.snd ≫ g)

tactic: exact (limit.w _ WalkingCospan.Hom.inr).symm
state_before: case h.e'_5.h.e_a
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
H₁ : Embedding ((forget TopCat).map f)
H₂ : Embedding ((forget TopCat).map g)
e_2✝ : (forget TopCat).obj ((cospan f g).obj WalkingCospan.one) = (forget TopCat).obj S
⊢ limit.π (cospan f g) WalkingCospan.one = pullback.snd ≫ g
Theorem: Submodule.comap_unop_mul
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: simp_rw [← map_equiv_eq_comap_symm, map_op_mul]
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 : A
⊢ comap (↑(LinearEquiv.symm (opLinearEquiv R))) (M * N) =
    comap (↑(LinearEquiv.symm (opLinearEquiv R))) N * comap (↑(LinearEquiv.symm (opLinearEquiv R))) M
Theorem: mul_eq_right₀
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: rw [Iff.comm, ← mul_left_inj' hb, one_mul]
state_before: α : Type ?u.11641
M₀ : Type u_1
G₀ : Type ?u.11647
M₀' : Type ?u.11650
G₀' : Type ?u.11653
F : Type ?u.11656
F' : Type ?u.11659
inst✝ : CancelMonoidWithZero M₀
a b c : M₀
hb : b ≠ 0
⊢ a * b = b ↔ a = 1
Theorem: DiscreteQuotient.ofLE_refl_apply
File: Mathlib/Topology/DiscreteQuotient.lean

tactic: simp
state_before: α : Type ?u.13387
X : Type u_1
Y : Type ?u.13393
Z : Type ?u.13396
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
S A B C : DiscreteQuotient X
a : Quotient A.toSetoid
⊢ ofLE (_ : A ≤ A) a = a
Theorem: Nat.mod_mul_left_div_self
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: rw [mul_comm k, mod_mul_right_div_self]
state_before: m✝ n✝ k✝ l m n k : ℕ
⊢ m % (k * n) / n = m / n % k
Theorem: integrableOn_Iic_iff_integrableOn_Iio
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: rw [measure_singleton]
state_before: α : Type u_1
β : Type ?u.4685922
E : Type u_2
F : Type ?u.4685928
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
inst✝² : PartialOrder α
inst✝¹ : MeasurableSingletonClass α
f : α → E
μ : MeasureTheory.Measure α
a b : α
inst✝ : NoAtoms μ
⊢ ↑↑μ {b} ≠ ⊤

tactic: exact ENNReal.zero_ne_top
state_before: α : Type u_1
β : Type ?u.4685922
E : Type u_2
F : Type ?u.4685928
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
inst✝² : PartialOrder α
inst✝¹ : MeasurableSingletonClass α
f : α → E
μ : MeasureTheory.Measure α
a b : α
inst✝ : NoAtoms μ
⊢ 0 ≠ ⊤