tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.SimpleFunc.setToSimpleFunc_smul_real
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: rw [smul_eq_map c f, map_setToSimpleFunc T h_add hf]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.296683
G : Type ?u.296686
𝕜 : Type ?u.296689
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → E →L[ℝ] F
h_add : FinMeasAdditive μ T
c : ℝ
f : α →ₛ E
hf : Integrable ↑f
⊢ setToSimpleFunc T (c • f) = ∑ x in SimpleFunc.range f, ↑(T (↑f ⁻¹' {x})) (c • x)

tactic: dsimp only
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.296683
G : Type ?u.296686
𝕜 : Type ?u.296689
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → E →L[ℝ] F
h_add : FinMeasAdditive μ T
c : ℝ
f : α →ₛ E
hf : Integrable ↑f
⊢ (fun x x_1 => x • x_1) c 0 = 0

tactic: rw [smul_zero]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.296683
G : Type ?u.296686
𝕜 : Type ?u.296689
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → E →L[ℝ] F
h_add : FinMeasAdditive μ T
c : ℝ
f : α →ₛ E
hf : Integrable ↑f
⊢ c • 0 = 0

tactic: rw [ContinuousLinearMap.map_smul (T (f ⁻¹' {b})) c b]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.296683
G : Type ?u.296686
𝕜 : Type ?u.296689
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → E →L[ℝ] F
h_add : FinMeasAdditive μ T
c : ℝ
f : α →ₛ E
hf : Integrable ↑f
b : E
x✝ : b ∈ SimpleFunc.range f
⊢ ↑(T (↑f ⁻¹' {b})) (c • b) = c • ↑(T (↑f ⁻¹' {b})) b

tactic: simp only [setToSimpleFunc, smul_sum, smul_smul, mul_comm]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.296683
G : Type ?u.296686
𝕜 : Type ?u.296689
p : ℝ≥0∞
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
T : Set α → E →L[ℝ] F
h_add : FinMeasAdditive μ T
c : ℝ
f : α →ₛ E
hf : Integrable ↑f
⊢ ∑ x in SimpleFunc.range f, c • ↑(T (↑f ⁻¹' {x})) x = c • setToSimpleFunc T f
Theorem: Real.tan_sq_div_one_add_tan_sq
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp only [← tan_mul_cos hx, mul_pow, ← inv_one_add_tan_sq hx, div_eq_mul_inv, one_mul]
state_before: x✝ y x : ℝ
hx : cos x ≠ 0
⊢ tan x ^ 2 / (1 + tan x ^ 2) = sin x ^ 2
Theorem: List.leftpad_eq_leftpadTR
File: Std/Data/List/Basic.lean

tactic: funext α n a l
state_before: ⊢ @leftpad = @leftpadTR

tactic: simp [leftpad, leftpadTR, replicateTR_loop_eq]
state_before: case h.h.h.h
α : Type u_1
n : Nat
a : α
l : List α
⊢ leftpad n a l = leftpadTR n a l
Theorem: Ordinal.omega_isLimit
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: let ⟨n, e⟩ := lt_omega.1 h
state_before: o : Ordinal
h : o < ω
⊢ succ o < ω

tactic: rw [e]
state_before: o : Ordinal
h : o < ω
n : ℕ
e : o = ↑n
⊢ succ o < ω

tactic: exact nat_lt_omega (n + 1)
state_before: o : Ordinal
h : o < ω
n : ℕ
e : o = ↑n
⊢ succ ↑n < ω
Theorem: Finset.weightedVSub_weightedVSubVSubWeights
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: rw [weightedVSubVSubWeights, ← affineCombination_vsub,
  s.affineCombination_affineCombinationSingleWeights k p hi,
  s.affineCombination_affineCombinationSingleWeights k p hj]
state_before: k : Type u_3
V : Type u_2
P : Type u_4
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.453666
s₂ : Finset ι₂
inst✝ : DecidableEq ι
p : ι → P
i j : ι
hi : i ∈ s
hj : j ∈ s
⊢ ↑(weightedVSub s p) (weightedVSubVSubWeights k i j) = p i -ᵥ p j
Theorem: FreeProduct.lift_of
File: Mathlib/GroupTheory/FreeProduct.lean

tactic: conv_rhs => rw [← lift.symm_apply_apply fi, lift_symm_apply, MonoidHom.comp_apply]
state_before: ι : Type u_3
M : ι → Type u_2
inst✝² : (i : ι) → Monoid (M i)
N✝ : Type ?u.134151
inst✝¹ : Monoid N✝
N : Type u_1
inst✝ : Monoid N
fi : (i : ι) → M i →* N
i : ι
m : M i
⊢ ↑(↑lift fi) (↑of m) = ↑(fi i) m
Theorem: IsLocallyConstant.range_finite
File: Mathlib/Topology/LocallyConstant/Basic.lean

tactic: letI : TopologicalSpace Y := ⊥
state_before: X : Type u_1
Y : Type u_2
Z : Type ?u.6330
α : Type ?u.6333
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
f : X → Y
hf : IsLocallyConstant f
⊢ Set.Finite (range f)

tactic: haveI := discreteTopology_bot Y
state_before: X : Type u_1
Y : Type u_2
Z : Type ?u.6330
α : Type ?u.6333
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
f : X → Y
hf : IsLocallyConstant f
this : TopologicalSpace Y := ⊥
⊢ Set.Finite (range f)

tactic: exact (isCompact_range hf.continuous).finite_of_discrete
state_before: X : Type u_1
Y : Type u_2
Z : Type ?u.6330
α : Type ?u.6333
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
f : X → Y
hf : IsLocallyConstant f
this✝ : TopologicalSpace Y := ⊥
this : DiscreteTopology Y
⊢ Set.Finite (range f)
Theorem: Polynomial.IsWeaklyEisensteinAt.pow_natDegree_le_of_root_of_monic_mem
File: Mathlib/RingTheory/Polynomial/Eisenstein/Basic.lean

tactic: intro i hi
state_before: R : Type u
inst✝² : CommRing R
𝓟 : Ideal R
f : R[X]
hf : IsWeaklyEisensteinAt f 𝓟
S : Type v
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : R
hroot : IsRoot f x
hmo : Monic f
⊢ ∀ (i : ℕ), natDegree f ≤ i → x ^ i ∈ 𝓟

tactic: obtain ⟨k, hk⟩ := exists_add_of_le hi
state_before: R : Type u
inst✝² : CommRing R
𝓟 : Ideal R
f : R[X]
hf : IsWeaklyEisensteinAt f 𝓟
S : Type v
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : R
hroot : IsRoot f x
hmo : Monic f
i : ℕ
hi : natDegree f ≤ i
⊢ x ^ i ∈ 𝓟

tactic: rw [hk, pow_add]
state_before: case intro
R : Type u
inst✝² : CommRing R
𝓟 : Ideal R
f : R[X]
hf : IsWeaklyEisensteinAt f 𝓟
S : Type v
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : R
hroot : IsRoot f x
hmo : Monic f
i : ℕ
hi : natDegree f ≤ i
k : ℕ
hk : i = natDegree f + k
⊢ x ^ i ∈ 𝓟

tactic: suffices x ^ f.natDegree ∈ 𝓟 by exact mul_mem_right (x ^ k) 𝓟 this
state_before: case intro
R : Type u
inst✝² : CommRing R
𝓟 : Ideal R
f : R[X]
hf : IsWeaklyEisensteinAt f 𝓟
S : Type v
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : R
hroot : IsRoot f x
hmo : Monic f
i : ℕ
hi : natDegree f ≤ i
k : ℕ
hk : i = natDegree f + k
⊢ x ^ natDegree f * x ^ k ∈ 𝓟

tactic: rw [IsRoot.def, eval_eq_sum_range, Finset.range_add_one,
  Finset.sum_insert Finset.not_mem_range_self, Finset.sum_range, hmo.coeff_natDegree, one_mul] at
  *
state_before: case intro
R : Type u
inst✝² : CommRing R
𝓟 : Ideal R
f : R[X]
hf : IsWeaklyEisensteinAt f 𝓟
S : Type v
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : R
hroot : IsRoot f x
hmo : Monic f
i : ℕ
hi : natDegree f ≤ i
k : ℕ
hk : i = natDegree f + k
⊢ x ^ natDegree f ∈ 𝓟

tactic: rw [eq_neg_of_add_eq_zero_left hroot, Ideal.neg_mem_iff]
state_before: case intro
R : Type u
inst✝² : CommRing R
𝓟 : Ideal R
f : R[X]
hf : IsWeaklyEisensteinAt f 𝓟
S : Type v
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : R
hroot : x ^ natDegree f + ∑ i : Fin (natDegree f), coeff f ↑i * x ^ ↑i = 0
hmo : Monic f
i : ℕ
hi : natDegree f ≤ i
k : ℕ
hk : i = natDegree f + k
⊢ x ^ natDegree f ∈ 𝓟

tactic: refine' Submodule.sum_mem _ fun i _ => mul_mem_right _ _ (hf.mem (Fin.is_lt i))
state_before: case intro
R : Type u
inst✝² : CommRing R
𝓟 : Ideal R
f : R[X]
hf : IsWeaklyEisensteinAt f 𝓟
S : Type v
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : R
hroot : x ^ natDegree f + ∑ i : Fin (natDegree f), coeff f ↑i * x ^ ↑i = 0
hmo : Monic f
i : ℕ
hi : natDegree f ≤ i
k : ℕ
hk : i = natDegree f + k
⊢ ∑ i : Fin (natDegree f), coeff f ↑i * x ^ ↑i ∈ 𝓟

tactic: exact mul_mem_right (x ^ k) 𝓟 this
state_before: R : Type u
inst✝² : CommRing R
𝓟 : Ideal R
f : R[X]
hf : IsWeaklyEisensteinAt f 𝓟
S : Type v
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : R
hroot : IsRoot f x
hmo : Monic f
i : ℕ
hi : natDegree f ≤ i
k : ℕ
hk : i = natDegree f + k
this : x ^ natDegree f ∈ 𝓟
⊢ x ^ natDegree f * x ^ k ∈ 𝓟
Theorem: Finset.mem_prod_list_ofFn
File: Mathlib/Data/Finset/Pointwise.lean

tactic: rw [← mem_coe, coe_list_prod, List.map_ofFn, Set.mem_prod_list_ofFn]
state_before: F : Type ?u.406111
α : Type u_1
β : Type ?u.406117
γ : Type ?u.406120
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : Monoid α
s✝ t : Finset α
a✝ : α
m n : ℕ
a : α
s : Fin n → Finset α
⊢ a ∈ List.prod (List.ofFn s) ↔ ∃ f, List.prod (List.ofFn fun i => ↑(f i)) = a

tactic: rfl
state_before: F : Type ?u.406111
α : Type u_1
β : Type ?u.406117
γ : Type ?u.406120
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : Monoid α
s✝ t : Finset α
a✝ : α
m n : ℕ
a : α
s : Fin n → Finset α
⊢ (∃ f, List.prod (List.ofFn fun i => ↑(f i)) = a) ↔ ∃ f, List.prod (List.ofFn fun i => ↑(f i)) = a
Theorem: Polynomial.eval_monomial_one_add_sub
File: Mathlib/Data/Polynomial/Eval.lean

tactic: have cast_succ : (d + 1 : S) = ((d.succ : ℕ) : S) := by simp only [Nat.cast_succ]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
x : R
inst✝ : CommRing S
d : ℕ
y : S
⊢ eval (1 + y) (↑(monomial d) (↑d + 1)) - eval y (↑(monomial d) (↑d + 1)) =
    ∑ x_1 in range (d + 1), ↑(Nat.choose (d + 1) x_1) * (↑x_1 * y ^ (x_1 - 1))

tactic: rw [cast_succ, eval_monomial, eval_monomial, add_comm, add_pow]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
x : R
inst✝ : CommRing S
d : ℕ
y : S
cast_succ : ↑d + 1 = ↑(Nat.succ d)
⊢ eval (1 + y) (↑(monomial d) (↑d + 1)) - eval y (↑(monomial d) (↑d + 1)) =
    ∑ x_1 in range (d + 1), ↑(Nat.choose (d + 1) x_1) * (↑x_1 * y ^ (x_1 - 1))

tactic: rw [sum_range_succ, mul_add, Nat.choose_self, Nat.cast_one, one_mul, add_sub_cancel, mul_sum,
  sum_range_succ', Nat.cast_zero, zero_mul, mul_zero, add_zero]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
x : R
inst✝ : CommRing S
d : ℕ
y : S
cast_succ : ↑d + 1 = ↑(Nat.succ d)
⊢ ↑(Nat.succ d) * ∑ x in range (d + 1), ↑(Nat.choose d x) * y ^ x - ↑(Nat.succ d) * y ^ d =
    ∑ x_1 in range (d + 1), ↑(Nat.choose (d + 1) x_1) * (↑x_1 * y ^ (x_1 - 1))

tactic: refine sum_congr rfl fun y _hy => ?_
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
x : R
inst✝ : CommRing S
d : ℕ
y : S
cast_succ : ↑d + 1 = ↑(Nat.succ d)
⊢ ∑ x in range d, ↑(Nat.succ d) * (↑(Nat.choose d x) * y ^ x) =
    ∑ k in range d, ↑(Nat.choose (d + 1) (k + 1)) * (↑(k + 1) * y ^ (k + 1 - 1))

tactic: rw [← mul_assoc, ← mul_assoc, ← Nat.cast_mul, Nat.succ_mul_choose_eq, Nat.cast_mul,
  Nat.add_sub_cancel]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
x : R
inst✝ : CommRing S
d : ℕ
y✝ : S
cast_succ : ↑d + 1 = ↑(Nat.succ d)
y : ℕ
_hy : y ∈ range d
⊢ ↑(Nat.succ d) * (↑(Nat.choose d y) * y✝ ^ y) = ↑(Nat.choose (d + 1) (y + 1)) * (↑(y + 1) * y✝ ^ (y + 1 - 1))

tactic: simp only [Nat.cast_succ]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
x : R
inst✝ : CommRing S
d : ℕ
y : S
⊢ ↑d + 1 = ↑(Nat.succ d)
Theorem: UniformSpace.Completion.extension_map
File: Mathlib/Topology/UniformSpace/Completion.lean

tactic: intro a
state_before: α : Type u_3
inst✝⁴ : UniformSpace α
β : Type u_2
inst✝³ : UniformSpace β
γ : Type u_1
inst✝² : UniformSpace γ
f✝ : α → β
inst✝¹ : CompleteSpace γ
inst✝ : SeparatedSpace γ
f : β → γ
g : α → β
hf : UniformContinuous f
hg : UniformContinuous g
⊢ ∀ (a : α), (Completion.extension f ∘ Completion.map g) (↑α a) = Completion.extension (f ∘ g) (↑α a)

tactic: rw [extension_coe (hf.comp hg), Function.comp_apply, map_coe hg, extension_coe hf,
  Function.comp_apply]
state_before: α : Type u_3
inst✝⁴ : UniformSpace α
β : Type u_2
inst✝³ : UniformSpace β
γ : Type u_1
inst✝² : UniformSpace γ
f✝ : α → β
inst✝¹ : CompleteSpace γ
inst✝ : SeparatedSpace γ
f : β → γ
g : α → β
hf : UniformContinuous f
hg : UniformContinuous g
a : α
⊢ (Completion.extension f ∘ Completion.map g) (↑α a) = Completion.extension (f ∘ g) (↑α a)
Theorem: AddTorsor.subsingleton_iff
File: Mathlib/Algebra/AddTorsor.lean

tactic: inhabit P
state_before: G : Type u_1
P : Type u_2
inst✝¹ : AddGroup G
inst✝ : AddTorsor G P
⊢ Subsingleton G ↔ Subsingleton P

tactic: exact (Equiv.vaddConst default).subsingleton_congr
state_before: G : Type u_1
P : Type u_2
inst✝¹ : AddGroup G
inst✝ : AddTorsor G P
inhabited_h : Inhabited P
⊢ Subsingleton G ↔ Subsingleton P
Theorem: CategoryTheory.CostructuredArrow.unop_left_comp_underlyingIso_hom_unop
File: Mathlib/CategoryTheory/Subobject/Comma.lean

tactic: conv_lhs =>
  congr
  rw [← Quiver.Hom.unop_op f.unop.left]
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
S : C ⥤ D
T : D
A : CostructuredArrow S T
P : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ A.op
inst✝ : Mono f.unop.left.op
⊢ f.unop.left ≫ (Subobject.underlyingIso f.unop.left.op).hom.unop = (Subobject.arrow (Subobject.mk f.unop.left.op)).unop

tactic: rw [← unop_comp, Subobject.underlyingIso_hom_comp_eq_mk]
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
S : C ⥤ D
T : D
A : CostructuredArrow S T
P : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ A.op
inst✝ : Mono f.unop.left.op
⊢ f.unop.left.op.unop ≫ (Subobject.underlyingIso f.unop.left.op).hom.unop =
    (Subobject.arrow (Subobject.mk f.unop.left.op)).unop
Theorem: Complex.cpow_mul
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

tactic: simp only [cpow_def]
state_before: x y z : ℂ
h₁ : -π < (log x * y).im
h₂ : (log x * y).im ≤ π
⊢ x ^ (y * z) = (x ^ y) ^ z

tactic: split_ifs <;> simp_all [exp_ne_zero, log_exp h₁ h₂, mul_assoc]
state_before: x y z : ℂ
h₁ : -π < (log x * y).im
h₂ : (log x * y).im ≤ π
⊢ (if x = 0 then if y * z = 0 then 1 else 0 else exp (log x * (y * z))) =
    if (if x = 0 then if y = 0 then 1 else 0 else exp (log x * y)) = 0 then if z = 0 then 1 else 0
    else exp (log (if x = 0 then if y = 0 then 1 else 0 else exp (log x * y)) * z)
Theorem: Set.maps_range_to
File: Mathlib/Data/Set/Function.lean

tactic: rw [← image_univ, maps_image_to]
state_before: α : Type u_2
β : Type u_1
γ : Type u_3
ι : Sort ?u.23873
π : α → Type ?u.23878
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g✝ g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → β
g : γ → α
s : Set β
⊢ MapsTo f (range g) s ↔ MapsTo (f ∘ g) univ s
Theorem: WittVector.ghostFun_mul
File: Mathlib/RingTheory/WittVector/Basic.lean

tactic: ghost_fun_tac X 0 * X 1, ![x.coeff, y.coeff]
state_before: p : ℕ
R : Type u_1
S : Type ?u.727613
T : Type ?u.727616
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type ?u.727631
β : Type ?u.727634
x y : 𝕎 R
⊢ WittVector.ghostFun (x * y) = WittVector.ghostFun x * WittVector.ghostFun y
Theorem: CategoryTheory.Functor.map_inv
File: Mathlib/CategoryTheory/Iso.lean

tactic: apply eq_inv_of_hom_inv_id
state_before: C : Type u
inst✝² : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝ : IsIso f
⊢ F.map (inv f) = inv (F.map f)

tactic: simp [← F.map_comp]
state_before: case hom_inv_id
C : Type u
inst✝² : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝ : IsIso f
⊢ F.map f ≫ F.map (inv f) = 𝟙 (F.obj X)
Theorem: MeasureTheory.OuterMeasure.restrict_empty
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.104853
R : Type ?u.104856
R' : Type ?u.104859
ms : Set (OuterMeasure α)
m✝ m : OuterMeasure α
s : Set α
⊢ ↑(↑(restrict ∅) m) s = ↑0 s
Theorem: CategoryTheory.preserves_epi_of_preservesColimit
File: Mathlib/CategoryTheory/Limits/Constructions/EpiMono.lean

tactic: have := isColimitPushoutCoconeMapOfIsColimit F _ (PushoutCocone.isColimitMkIdId f)
state_before: C : Type u₁
D : Type u₂
inst✝³ : Category C
inst✝² : Category D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : PreservesColimit (span f f) F
inst✝ : Epi f
⊢ Epi (F.map f)

tactic: simp_rw [F.map_id] at this
state_before: C : Type u₁
D : Type u₂
inst✝³ : Category C
inst✝² : Category D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : PreservesColimit (span f f) F
inst✝ : Epi f
this : IsColimit (PushoutCocone.mk (F.map (𝟙 Y)) (F.map (𝟙 Y)) (_ : F.map f ≫ F.map (𝟙 Y) = F.map f ≫ F.map (𝟙 Y)))
⊢ Epi (F.map f)

tactic: apply PushoutCocone.epi_of_isColimitMkIdId _ this
state_before: C : Type u₁
D : Type u₂
inst✝³ : Category C
inst✝² : Category D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝¹ : PreservesColimit (span f f) F
inst✝ : Epi f
this : IsColimit (PushoutCocone.mk (𝟙 (F.obj Y)) (𝟙 (F.obj Y)) (_ : F.map f ≫ 𝟙 (F.obj Y) = F.map f ≫ 𝟙 (F.obj Y)))
⊢ Epi (F.map f)
Theorem: intervalIntegral.norm_integral_min_max
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: cases le_total a b <;> simp [*, integral_symm a b]
state_before: ι : Type ?u.11464703
𝕜 : Type ?u.11464706
E : Type u_1
F : Type ?u.11464712
A : Type ?u.11464715
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f✝ g : ℝ → E
μ : MeasureTheory.Measure ℝ
f : ℝ → E
⊢ ‖∫ (x : ℝ) in min a b..max a b, f x ∂μ‖ = ‖∫ (x : ℝ) in a..b, f x ∂μ‖
Theorem: Ordnode.Valid'.merge_lemma
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: linarith
state_before: α : Type ?u.353008
inst✝ : Preorder α
a b c : ℕ
h₁ : 3 * a < b + c + 1
h₂ : b ≤ 3 * c
⊢ 2 * (a + b) ≤ 9 * c + 5
Theorem: Representation.smul_ofModule_asModule
File: Mathlib/RepresentationTheory/Basic.lean

tactic: dsimp
state_before: k : Type u_1
G : Type u_2
V : Type ?u.428533
inst✝⁵ : CommSemiring k
inst✝⁴ : Monoid G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
ρ : Representation k G V
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : Module (MonoidAlgebra k G) M
r : MonoidAlgebra k G
m : asModule (ofModule M)
⊢ ↑(RestrictScalars.addEquiv k (MonoidAlgebra k G) M) (↑(asModuleEquiv (ofModule M)) (r • m)) =
    r • ↑(RestrictScalars.addEquiv k (MonoidAlgebra k G) M) (↑(asModuleEquiv (ofModule M)) m)

tactic: simp only [AddEquiv.apply_symm_apply, ofModule_asAlgebraHom_apply_apply]
state_before: k : Type u_1
G : Type u_2
V : Type ?u.428533
inst✝⁵ : CommSemiring k
inst✝⁴ : Monoid G
inst✝³ : AddCommMonoid V
inst✝² : Module k V
ρ : Representation k G V
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : Module (MonoidAlgebra k G) M
r : MonoidAlgebra k G
m : asModule (ofModule M)
⊢ ↑(RestrictScalars.addEquiv k (MonoidAlgebra k G) M)
      (↑(↑(asAlgebraHom (ofModule M)) r) (↑(asModuleEquiv (ofModule M)) m)) =
    r • ↑(RestrictScalars.addEquiv k (MonoidAlgebra k G) M) (↑(asModuleEquiv (ofModule M)) m)
Theorem: Nat.div2_bit
File: Mathlib/Init/Data/Nat/Bitwise.lean

tactic: rw [bit_val, div2_val, Nat.add_comm, add_mul_div_left, div_eq_of_lt, Nat.zero_add]
<;> cases b
<;> exact by decide
state_before: b : Bool
n : ℕ
⊢ div2 (bit b n) = n

tactic: decide
state_before: n : ℕ
⊢ 0 < 2
Theorem: iSup_range
File: Mathlib/Order/CompleteLattice.lean

tactic: rw [← iSup_subtype'', iSup_range']
state_before: α : Type u_1
β : Type u_2
β₂ : Type ?u.111002
γ : Type ?u.111005
ι : Sort u_3
ι' : Sort ?u.111011
κ : ι → Sort ?u.111016
κ' : ι' → Sort ?u.111021
inst✝ : CompleteLattice α
f✝ g✝ s t : ι → α
a b : α
g : β → α
f : ι → β
⊢ (⨆ (b : β) (_ : b ∈ range f), g b) = ⨆ (i : ι), g (f i)
Theorem: Set.range_sigmaMk
File: Mathlib/Data/Set/Sigma.lean

tactic: apply Subset.antisymm
state_before: ι : Type u_1
ι' : Type ?u.81
α : ι → Type u_2
β : ι → Type ?u.91
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i✝ j : ι
a : α i✝
i : ι
⊢ range (Sigma.mk i) = Sigma.fst ⁻¹' {i}

tactic: rintro _ ⟨b, rfl⟩
state_before: case h₁
ι : Type u_1
ι' : Type ?u.81
α : ι → Type u_2
β : ι → Type ?u.91
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i✝ j : ι
a : α i✝
i : ι
⊢ range (Sigma.mk i) ⊆ Sigma.fst ⁻¹' {i}

tactic: simp
state_before: case h₁.intro
ι : Type u_1
ι' : Type ?u.81
α : ι → Type u_2
β : ι → Type ?u.91
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i✝ j : ι
a : α i✝
i : ι
b : α i
⊢ { fst := i, snd := b } ∈ Sigma.fst ⁻¹' {i}

tactic: rintro ⟨x, y⟩ (rfl | _)
state_before: case h₂
ι : Type u_1
ι' : Type ?u.81
α : ι → Type u_2
β : ι → Type ?u.91
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i✝ j : ι
a : α i✝
i : ι
⊢ Sigma.fst ⁻¹' {i} ⊆ range (Sigma.mk i)

tactic: exact mem_range_self y
state_before: case h₂.mk.refl
ι : Type u_1
ι' : Type ?u.81
α : ι → Type u_2
β : ι → Type ?u.91
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x✝ : (i : ι) × α i
i j : ι
a : α i
x : ι
y : α x
⊢ { fst := x, snd := y } ∈ range (Sigma.mk { fst := x, snd := y }.fst)
Theorem: QuaternionAlgebra.star_add_self'
File: Mathlib/Algebra/Quaternion.lean

tactic: rw [add_comm, self_add_star']
state_before: S : Type ?u.310983
T : Type ?u.310986
R : Type u_1
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
⊢ star a + a = ↑(2 * a.re)
Theorem: Filter.map_sigma_mk_comap
File: Mathlib/Order/Filter/Bases.lean

tactic: refine' (((basis_sets _).comap _).map _).eq_of_same_basis _
state_before: α : Type u_3
β : Type u_4
γ : Type ?u.83924
ι : Sort ?u.83927
ι' : Sort ?u.83930
π : α → Type u_1
π' : β → Type u_2
f : α → β
hf : Function.Injective f
g : (a : α) → π a → π' (f a)
a : α
l : Filter (π' (f a))
⊢ map (Sigma.mk a) (comap (g a) l) = comap (Sigma.map f g) (map (Sigma.mk (f a)) l)

tactic: convert ((basis_sets l).map (Sigma.mk (f a))).comap (Sigma.map f g)
state_before: α : Type u_3
β : Type u_4
γ : Type ?u.83924
ι : Sort ?u.83927
ι' : Sort ?u.83930
π : α → Type u_1
π' : β → Type u_2
f : α → β
hf : Function.Injective f
g : (a : α) → π a → π' (f a)
a : α
l : Filter (π' (f a))
⊢ HasBasis (comap (Sigma.map f g) (map (Sigma.mk (f a)) l)) (fun s => s ∈ l) fun i => Sigma.mk a '' (g a ⁻¹' id i)

tactic: apply image_sigmaMk_preimage_sigmaMap hf
state_before: case h.e'_5.h
α : Type u_3
β : Type u_4
γ : Type ?u.83924
ι : Sort ?u.83927
ι' : Sort ?u.83930
π : α → Type u_1
π' : β → Type u_2
f : α → β
hf : Function.Injective f
g : (a : α) → π a → π' (f a)
a : α
l : Filter (π' (f a))
x✝ : Set (π' (f a))
⊢ Sigma.mk a '' (g a ⁻¹' id x✝) = Sigma.map f g ⁻¹' (Sigma.mk (f a) '' id x✝)
Theorem: Equiv.Perm.apply_zpow_apply_eq_iff
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: rw [← mul_apply, Commute.self_zpow f, mul_apply, apply_eq_iff_eq]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
n : ℤ
x : α
⊢ ↑f (↑(f ^ n) x) = ↑(f ^ n) x ↔ ↑f x = x
Theorem: Set.preimage_sUnion
File: Mathlib/Data/Set/Lattice.lean

tactic: rw [sUnion_eq_biUnion, preimage_iUnion₂]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.224545
ι : Sort ?u.224548
ι' : Sort ?u.224551
ι₂ : Sort ?u.224554
κ : ι → Sort ?u.224559
κ₁ : ι → Sort ?u.224564
κ₂ : ι → Sort ?u.224569
κ' : ι' → Sort ?u.224574
f : α → β
s : Set (Set β)
⊢ f ⁻¹' ⋃₀ s = ⋃ (t : Set β) (_ : t ∈ s), f ⁻¹' t
Theorem: Nat.le_mul_of_pos_right
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: conv =>
  lhs
  rw [← mul_one m]
state_before: m n k l : ℕ
h : 0 < n
⊢ m ≤ m * n

tactic: exact mul_le_mul_of_nonneg_left h.nat_succ_le (zero_le _)
state_before: m n k l : ℕ
h : 0 < n
⊢ m * 1 ≤ m * n