tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.withDensityᵥ_add
File: Mathlib/MeasureTheory/Measure/WithDensityVectorMeasure.lean

tactic: ext1 i hi
state_before: α : Type u_2
β : Type ?u.30911
m : MeasurableSpace α
μ ν : Measure α
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
hf : Integrable f
hg : Integrable g
⊢ withDensityᵥ μ (f + g) = withDensityᵥ μ f + withDensityᵥ μ g

tactic: rw [withDensityᵥ_apply (hf.add hg) hi, VectorMeasure.add_apply, withDensityᵥ_apply hf hi,
  withDensityᵥ_apply hg hi]
state_before: case h
α : Type u_2
β : Type ?u.30911
m : MeasurableSpace α
μ ν : Measure α
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
hf : Integrable f
hg : Integrable g
i : Set α
hi : MeasurableSet i
⊢ ↑(withDensityᵥ μ (f + g)) i = ↑(withDensityᵥ μ f + withDensityᵥ μ g) i

tactic: simp_rw [Pi.add_apply]
state_before: case h
α : Type u_2
β : Type ?u.30911
m : MeasurableSpace α
μ ν : Measure α
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
hf : Integrable f
hg : Integrable g
i : Set α
hi : MeasurableSet i
⊢ (∫ (x : α) in i, (f + g) x ∂μ) = (∫ (x : α) in i, f x ∂μ) + ∫ (x : α) in i, g x ∂μ

tactic: rw [integral_add] <;> rw [← integrableOn_univ]
state_before: case h
α : Type u_2
β : Type ?u.30911
m : MeasurableSpace α
μ ν : Measure α
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
hf : Integrable f
hg : Integrable g
i : Set α
hi : MeasurableSet i
⊢ (∫ (x : α) in i, f x + g x ∂μ) = (∫ (x : α) in i, f x ∂μ) + ∫ (x : α) in i, g x ∂μ

tactic: exact hf.integrableOn.restrict MeasurableSet.univ
state_before: case h.hf
α : Type u_2
β : Type ?u.30911
m : MeasurableSpace α
μ ν : Measure α
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
hf : Integrable f
hg : Integrable g
i : Set α
hi : MeasurableSet i
⊢ IntegrableOn (fun x => f x) Set.univ

tactic: exact hg.integrableOn.restrict MeasurableSet.univ
state_before: case h.hg
α : Type u_2
β : Type ?u.30911
m : MeasurableSpace α
μ ν : Measure α
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
hf : Integrable f
hg : Integrable g
i : Set α
hi : MeasurableSet i
⊢ IntegrableOn (fun x => g x) Set.univ
Theorem: Num.to_of_nat
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [Nat.cast_zero, cast_zero]
state_before: ⊢ ↑↑0 = 0

tactic: rw [Nat.cast_succ, add_one, succ_to_nat, to_of_nat n]
state_before: n : ℕ
⊢ ↑↑(n + 1) = n + 1
Theorem: PNat.card_fintype_Ico
File: Mathlib/Data/PNat/Interval.lean

tactic: rw [← card_Ico, Fintype.card_ofFinset]
state_before: a b : ℕ+
⊢ Fintype.card ↑(Set.Ico a b) = ↑b - ↑a
Theorem: Algebra.IsIntegral.of_finite
File: Mathlib/RingTheory/IntegralClosure.lean

tactic: apply RingHom.Finite.to_isIntegral
state_before: R : Type u_1
A : Type u_2
B : Type ?u.630412
S : Type ?u.630415
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
h : Module.Finite R A
⊢ Algebra.IsIntegral R A

tactic: rw [RingHom.Finite]
state_before: case h
R : Type u_1
A : Type u_2
B : Type ?u.630412
S : Type ?u.630415
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
h : Module.Finite R A
⊢ RingHom.Finite (algebraMap R A)

tactic: convert h
state_before: case h
R : Type u_1
A : Type u_2
B : Type ?u.630412
S : Type ?u.630415
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
h : Module.Finite R A
⊢ Module.Finite R A

tactic: ext
state_before: case h.e'_5.h.e'_5
R : Type u_1
A : Type u_2
B : Type ?u.630412
S : Type ?u.630415
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
h : Module.Finite R A
⊢ RingHom.toAlgebra (algebraMap R A) = inst✝¹

tactic: exact (Algebra.smul_def _ _).symm
state_before: case h.e'_5.h.e'_5.h
R : Type u_1
A : Type u_2
B : Type ?u.630412
S : Type ?u.630415
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
h : Module.Finite R A
r✝ : R
x✝ : A
⊢ (let_fun I := RingHom.toAlgebra (algebraMap R A);
    r✝ • x✝) =
    r✝ • x✝
Theorem: mul_geom_sum
File: Mathlib/Algebra/GeomSum.lean

tactic: simpa using geom_sum_mul (op x) n
state_before: α : Type u
inst✝ : Ring α
x : α
n : ℕ
⊢ op ((x - 1) * ∑ i in range n, x ^ i) = op (x ^ n - 1)
Theorem: InnerProductGeometry.norm_div_sin_angle_sub_of_inner_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [← neg_eq_zero, ← inner_neg_right] at h
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x = 0 ∨ y ≠ 0
⊢ ‖y‖ / Real.sin (angle x (x - y)) = ‖x - y‖

tactic: rw [← neg_ne_zero] at h0
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x (-y) = 0
h0 : x = 0 ∨ y ≠ 0
⊢ ‖y‖ / Real.sin (angle x (x - y)) = ‖x - y‖

tactic: rw [sub_eq_add_neg, ← norm_neg, norm_div_sin_angle_add_of_inner_eq_zero h h0]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x (-y) = 0
h0 : x = 0 ∨ -y ≠ 0
⊢ ‖y‖ / Real.sin (angle x (x - y)) = ‖x - y‖
Theorem: Dfinsupp.subtypeDomain_def
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext i
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
p : ι → Prop
inst✝ : DecidablePred p
f : Π₀ (i : ι), β i
⊢ subtypeDomain p f = mk (Finset.subtype p (support f)) fun i => ↑f ↑↑i

tactic: by_cases h2 : f i ≠ 0 <;> try simp at h2; dsimp; simp [h2]
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
p : ι → Prop
inst✝ : DecidablePred p
f : Π₀ (i : ι), β i
i : Subtype p
⊢ ↑(subtypeDomain p f) i = ↑(mk (Finset.subtype p (support f)) fun i => ↑f ↑↑i) i

tactic: simp at h2
state_before: case neg
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
p : ι → Prop
inst✝ : DecidablePred p
f : Π₀ (i : ι), β i
i : Subtype p
h2 : ¬↑f ↑i ≠ 0
⊢ ↑(subtypeDomain p f) i = ↑(mk (Finset.subtype p (support f)) fun i => ↑f ↑↑i) i

tactic: dsimp
state_before: case neg
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
p : ι → Prop
inst✝ : DecidablePred p
f : Π₀ (i : ι), β i
i : Subtype p
h2 : ↑f ↑i = 0
⊢ ↑(subtypeDomain p f) i = ↑(mk (Finset.subtype p (support f)) fun i => ↑f ↑↑i) i

tactic: simp [h2]
state_before: case neg
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
inst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
p : ι → Prop
inst✝ : DecidablePred p
f : Π₀ (i : ι), β i
i : Subtype p
h2 : ↑f ↑i = 0
⊢ ↑f ↑i = if i ∈ Finset.subtype p (support f) then ↑f ↑i else 0
Theorem: Finsupp.add_eq_zero_iff
File: Mathlib/Data/Finsupp/Order.lean

tactic: simp [FunLike.ext_iff, forall_and]
state_before: ι : Type u_1
α : Type u_2
inst✝ : CanonicallyOrderedAddMonoid α
f g : ι →₀ α
⊢ f + g = 0 ↔ f = 0 ∧ g = 0
Theorem: IsOpenMap.preimage_frontier_subset_frontier_preimage
File: Mathlib/Topology/Maps.lean

tactic: simpa only [frontier_eq_closure_inter_closure, preimage_inter] using
  inter_subset_inter hf.preimage_closure_subset_closure_preimage
    hf.preimage_closure_subset_closure_preimage
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.196325
δ : Type ?u.196328
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
f : α → β
hf : IsOpenMap f
s : Set β
⊢ f ⁻¹' frontier s ⊆ frontier (f ⁻¹' s)
Theorem: FirstOrder.Language.card_relations_sum
File: Mathlib/ModelTheory/Basic.lean

tactic: simp [Language.sum]
state_before: L : Language
L' : Language
i : ℕ
⊢ (#Relations (Language.sum L L') i) = lift (#Relations L i) + lift (#Relations L' i)
Theorem: BumpCovering.toPouFun_zero_of_zero
File: Mathlib/Topology/PartitionOfUnity.lean

tactic: rw [toPouFun, h, MulZeroClass.zero_mul]
state_before: ι : Type u
X : Type v
inst✝ : TopologicalSpace X
s : Set X
f : BumpCovering ι X s
i : ι
x : X
h : ↑(toFun s f i) x = 0
⊢ toPouFun f i x = 0
Theorem: Algebra.smul_leftMulMatrix
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: simp only [leftMulMatrix_apply, LinearMap.toMatrix_apply, mul_comm, Basis.smul_apply,
  Basis.smul_repr, Finsupp.smul_apply, id.smul_eq_mul, LinearEquiv.map_smul, mul_smul_comm,
  coe_lmul_eq_mul, LinearMap.mul_apply']
state_before: R : Type u_3
S : Type u_5
T : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing S
inst✝⁸ : Ring T
inst✝⁷ : Algebra R S
inst✝⁶ : Algebra S T
inst✝⁵ : Algebra R T
inst✝⁴ : IsScalarTower R S T
m : Type u_1
n : Type u_2
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : DecidableEq n
b : Basis m R S
c : Basis n S T
x : T
ik jk : m × n
⊢ ↑(leftMulMatrix (Basis.smul b c)) x ik jk = ↑(leftMulMatrix b) (↑(leftMulMatrix c) x ik.snd jk.snd) ik.fst jk.fst
Theorem: Nat.dist_mul_left
File: Mathlib/Data/Nat/Dist.lean

tactic: rw [mul_comm k n, mul_comm k m, dist_mul_right, mul_comm]
state_before: k n m : ℕ
⊢ dist (k * n) (k * m) = k * dist n m
Theorem: orderOf_pow_dvd
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [orderOf_dvd_iff_pow_eq_one, pow_right_comm, pow_orderOf_eq_one, one_pow]
state_before: G : Type u
A : Type v
x y : G
a b : A
n✝ m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
n : ℕ
⊢ orderOf (x ^ n) ∣ orderOf x
Theorem: Nat.ArithmeticFunction.vonMangoldt_sum
File: Mathlib/NumberTheory/VonMangoldt.lean

tactic: refine' recOnPrimeCoprime _ _ _ n
state_before: n : ℕ
⊢ ∑ i in divisors n, ↑Λ i = Real.log ↑n

tactic: intro a b ha' hb' hab ha hb
state_before: case refine'_3
n : ℕ
⊢ ∀ (a b : ℕ),
    1 < a →
      1 < b →
        coprime a b →
          ∑ i in divisors a, ↑Λ i = Real.log ↑a →
            ∑ i in divisors b, ↑Λ i = Real.log ↑b → ∑ i in divisors (a * b), ↑Λ i = Real.log ↑(a * b)

tactic: simp only [vonMangoldt_apply, ← sum_filter] at ha hb⊢
state_before: case refine'_3
n a b : ℕ
ha' : 1 < a
hb' : 1 < b
hab : coprime a b
ha : ∑ i in divisors a, ↑Λ i = Real.log ↑a
hb : ∑ i in divisors b, ↑Λ i = Real.log ↑b
⊢ ∑ i in divisors (a * b), ↑Λ i = Real.log ↑(a * b)

tactic: rw [mul_divisors_filter_prime_pow hab, filter_union,
  sum_union (disjoint_divisors_filter_isPrimePow hab), ha, hb, Nat.cast_mul,
  Real.log_mul (cast_ne_zero.2 (pos_of_gt ha').ne') (cast_ne_zero.2 (pos_of_gt hb').ne')]
state_before: case refine'_3
n a b : ℕ
ha' : 1 < a
hb' : 1 < b
hab : coprime a b
ha : ∑ a in filter (fun a => IsPrimePow a) (divisors a), Real.log ↑(minFac a) = Real.log ↑a
hb : ∑ a in filter (fun a => IsPrimePow a) (divisors b), Real.log ↑(minFac a) = Real.log ↑b
⊢ ∑ a in filter (fun a => IsPrimePow a) (divisors (a * b)), Real.log ↑(minFac a) = Real.log ↑(a * b)

tactic: simp
state_before: case refine'_1
n : ℕ
⊢ ∑ i in divisors 0, ↑Λ i = Real.log ↑0

tactic: intro p k hp
state_before: case refine'_2
n : ℕ
⊢ ∀ (p n : ℕ), Prime p → ∑ i in divisors (p ^ n), ↑Λ i = Real.log ↑(p ^ n)

tactic: rw [sum_divisors_prime_pow hp, cast_pow, Real.log_pow, Finset.sum_range_succ', pow_zero,
  vonMangoldt_apply_one]
state_before: case refine'_2
n p k : ℕ
hp : Prime p
⊢ ∑ i in divisors (p ^ k), ↑Λ i = Real.log ↑(p ^ k)

tactic: simp [vonMangoldt_apply_pow (Nat.succ_ne_zero _), vonMangoldt_apply_prime hp]
state_before: case refine'_2
n p k : ℕ
hp : Prime p
⊢ ∑ k in range k, ↑Λ (p ^ (k + 1)) + 0 = ↑k * Real.log ↑p
Theorem: CategoryTheory.Limits.Multicofork.sigma_condition
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

tactic: ext
state_before: C : Type u
inst✝² : Category C
I : MultispanIndex C
K : Multicofork I
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
⊢ MultispanIndex.fstSigmaMap I ≫ Sigma.desc (π K) = MultispanIndex.sndSigmaMap I ≫ Sigma.desc (π K)

tactic: simp
state_before: case h
C : Type u
inst✝² : Category C
I : MultispanIndex C
K : Multicofork I
inst✝¹ : HasCoproduct I.left
inst✝ : HasCoproduct I.right
b✝ : I.L
⊢ Sigma.ι I.left b✝ ≫ MultispanIndex.fstSigmaMap I ≫ Sigma.desc (π K) =
    Sigma.ι I.left b✝ ≫ MultispanIndex.sndSigmaMap I ≫ Sigma.desc (π K)
Theorem: Set.range_inl
File: Mathlib/Data/Set/Image.lean

tactic: ext (_|_) <;> simp
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.78850
ι : Sort ?u.78853
ι' : Sort ?u.78856
f : ι → α
s t : Set α
⊢ range Sum.inl = {x | Sum.isLeft x = true}
Theorem: Localization.mk_left_injective
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: have : Nonempty s := One.nonempty
state_before: α : Type u_1
inst✝ : CancelCommMonoid α
s : Submonoid α
a₁ b₁ : α
a₂ b₂ b : { x // x ∈ s }
c d : α
h : (fun a => mk a b) c = (fun a => mk a b) d
⊢ c = d

tactic: simpa [-mk_eq_monoidOf_mk', mk_eq_mk_iff, r_iff_exists] using h
state_before: α : Type u_1
inst✝ : CancelCommMonoid α
s : Submonoid α
a₁ b₁ : α
a₂ b₂ b : { x // x ∈ s }
c d : α
h : (fun a => mk a b) c = (fun a => mk a b) d
this : Nonempty { x // x ∈ s }
⊢ c = d
Theorem: Real.log_neg_eq_log
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rw [← log_abs x, ← log_abs (-x), abs_neg]
state_before: x✝ y x : ℝ
⊢ log (-x) = log x
Theorem: Primrec.comp
File: Mathlib/Computability/Primrec.lean

tactic: cases @decode α _ n <;> simp [encodek]
state_before: α : Type u_3
β : Type u_1
σ : Type u_2
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
f : β → σ
g : α → β
hf : Primrec f
hg : Primrec g
n : ℕ
⊢ (Nat.casesOn (encode (decode n)) 0 fun n =>
      encode (Option.map f (decode (Nat.pred (encode (Option.map g (decode n))))))) =
    encode (Option.map (fun a => f (g a)) (decode n))
Theorem: Finset.image_symmDiff
File: Mathlib/Data/Finset/Image.lean

tactic: push_cast
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.94769
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t✝ : Finset β
a : α
b c : β
inst✝ : DecidableEq α
f : α → β
s t : Finset α
hf : Injective f
⊢ ↑(image f (s ∆ t)) = ↑(image f s ∆ image f t)

tactic: exact Set.image_symm_diff hf _ _
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.94769
inst✝¹ : DecidableEq β
f✝ g : α → β
s✝ : Finset α
t✝ : Finset β
a : α
b c : β
inst✝ : DecidableEq α
f : α → β
s t : Finset α
hf : Injective f
⊢ f '' ↑s ∆ ↑t = (f '' ↑s) ∆ (f '' ↑t)
Theorem: ite_self
File: src/lean/Init/SimpLemmas.lean

tactic: cases d <;> rfl
state_before: α : Sort u
c : Prop
d : Decidable c
a : α
⊢ ite c a a = a
Theorem: Real.Angle.sub_coe_pi_eq_add_coe_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [sub_eq_add_neg, neg_coe_pi]
state_before: θ : Angle
⊢ θ - ↑π = θ + ↑π
Theorem: toIcoMod_add_zsmul
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [toIcoMod, toIcoDiv_add_zsmul, toIcoMod, add_smul]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ toIcoMod hp a (b + m • p) = toIcoMod hp a b

tactic: abel
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ b + m • p - (toIcoDiv hp a b • p + m • p) = b - toIcoDiv hp a b • p
Theorem: Associates.dvd_out_iff
File: Mathlib/Algebra/GCDMonoid/Basic.lean

tactic: simp [Associates.out_mk, Associates.quotient_mk_eq_mk, mk_le_mk_iff_dvd_iff]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
a : α
b : Associates α
⊢ ∀ (a_1 : α),
    a ∣ Associates.out (Quotient.mk (Associated.setoid α) a_1) ↔ Associates.mk a ≤ Quotient.mk (Associated.setoid α) a_1
Theorem: gauge_ball
File: Mathlib/Analysis/Convex/Gauge.lean

tactic: rw [← smul_unitBall_of_pos hr, gauge_smul_left, Pi.smul_apply, gauge_unit_ball, smul_eq_mul,
  abs_of_nonneg hr.le, div_eq_inv_mul]
state_before: 𝕜 : Type ?u.286698
E : Type u_1
F : Type ?u.286704
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x✝ : E
hr : 0 < r
x : E
⊢ gauge (Metric.ball 0 r) x = ‖x‖ / r

tactic: simp_rw [mem_ball_zero_iff, norm_neg]
state_before: case symmetric
𝕜 : Type ?u.286698
E : Type u_1
F : Type ?u.286704
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x✝ : E
hr : 0 < r
x : E
⊢ ∀ (x : E), x ∈ Metric.ball 0 1 → -x ∈ Metric.ball 0 1

tactic: exact fun _ => id
state_before: case symmetric
𝕜 : Type ?u.286698
E : Type u_1
F : Type ?u.286704
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s : Set E
r : ℝ
x✝ : E
hr : 0 < r
x : E
⊢ ∀ (x : E), ‖x‖ < 1 → ‖x‖ < 1
Theorem: QuadraticForm.associated_comp
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: ext
state_before: S : Type u_3
R : Type u_1
R₁ : Type ?u.408596
M : Type u_2
inst✝⁹ : Ring R
inst✝⁸ : CommRing R₁
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : Module R₁ M
inst✝⁴ : CommSemiring S
inst✝³ : Algebra S R
inst✝² : Invertible 2
B₁ : BilinForm R M
Q : QuadraticForm R M
N : Type v
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : N →ₗ[R] M
⊢ ↑(associatedHom S) (comp Q f) = BilinForm.comp (↑(associatedHom S) Q) f f

tactic: simp only [QuadraticForm.comp_apply, BilinForm.comp_apply, associated_apply, LinearMap.map_add]
state_before: case H
S : Type u_3
R : Type u_1
R₁ : Type ?u.408596
M : Type u_2
inst✝⁹ : Ring R
inst✝⁸ : CommRing R₁
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : Module R₁ M
inst✝⁴ : CommSemiring S
inst✝³ : Algebra S R
inst✝² : Invertible 2
B₁ : BilinForm R M
Q : QuadraticForm R M
N : Type v
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : N →ₗ[R] M
x✝ y✝ : N
⊢ bilin (↑(associatedHom S) (comp Q f)) x✝ y✝ = bilin (BilinForm.comp (↑(associatedHom S) Q) f f) x✝ y✝
Theorem: QuadraticForm.polar_neg_left
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: rw [← neg_one_smul R x, polar_smul_left, neg_one_mul]
state_before: S : Type ?u.154687
R : Type u_1
R₁ : Type ?u.154693
M : Type u_2
inst✝³ : Ring R
inst✝² : CommRing R₁
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x y : M
⊢ polar (↑Q) (-x) y = -polar (↑Q) x y
Theorem: LieIdeal.derivedSeries_eq_bot_iff
File: Mathlib/Algebra/Lie/Solvable.lean

tactic: rw [← derivedSeries_eq_derivedSeriesOfIdeal_map, map_eq_bot_iff, ker_incl, eq_bot_iff]
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
k : ℕ
⊢ derivedSeries R { x // x ∈ ↑I } k = ⊥ ↔ derivedSeriesOfIdeal R L k I = ⊥
Theorem: Int.ediv_two_mul_two_add_one_of_odd
File: Mathlib/Data/Int/Parity.lean

tactic: rintro ⟨c, rfl⟩
state_before: m n : ℤ
⊢ Odd n → n / 2 * 2 + 1 = n

tactic: convert Int.ediv_add_emod' (2 * c + 1) 2
state_before: case intro
m c : ℤ
⊢ (2 * c + 1) / 2 * 2 + 1 = 2 * c + 1

tactic: simp [Int.add_emod]
state_before: case h.e'_2.h.e'_6
m c : ℤ
⊢ 1 = (2 * c + 1) % 2
Theorem: MeasureTheory.Subsingleton.stronglyMeasurable
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: let f_sf : α →ₛ β := ⟨f, fun x => ?_, Set.Subsingleton.finite Set.subsingleton_of_subsingleton⟩
state_before: α✝ : Type ?u.13198
β✝ : Type ?u.13201
γ : Type ?u.13204
ι : Type ?u.13207
inst✝³ : Countable ι
α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace β
inst✝ : Subsingleton β
f : α → β
⊢ StronglyMeasurable f

tactic: exact ⟨fun _ => f_sf, fun x => tendsto_const_nhds⟩
state_before: case refine_2
α✝ : Type ?u.13198
β✝ : Type ?u.13201
γ : Type ?u.13204
ι : Type ?u.13207
inst✝³ : Countable ι
α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace β
inst✝ : Subsingleton β
f : α → β
f_sf : α →ₛ β :=
  { toFun := f, measurableSet_fiber' := (_ : ∀ (x : β), MeasurableSet (f ⁻¹' {x})),
    finite_range' := (_ : Set.Finite (range f)) }
⊢ StronglyMeasurable f

tactic: have h_univ : f ⁻¹' {x} = Set.univ := by
  ext1 y
  simp
state_before: case refine_1
α✝ : Type ?u.13198
β✝ : Type ?u.13201
γ : Type ?u.13204
ι : Type ?u.13207
inst✝³ : Countable ι
α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace β
inst✝ : Subsingleton β
f : α → β
x : β
⊢ MeasurableSet (f ⁻¹' {x})

tactic: rw [h_univ]
state_before: case refine_1
α✝ : Type ?u.13198
β✝ : Type ?u.13201
γ : Type ?u.13204
ι : Type ?u.13207
inst✝³ : Countable ι
α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace β
inst✝ : Subsingleton β
f : α → β
x : β
h_univ : f ⁻¹' {x} = univ
⊢ MeasurableSet (f ⁻¹' {x})

tactic: exact MeasurableSet.univ
state_before: case refine_1
α✝ : Type ?u.13198
β✝ : Type ?u.13201
γ : Type ?u.13204
ι : Type ?u.13207
inst✝³ : Countable ι
α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace β
inst✝ : Subsingleton β
f : α → β
x : β
h_univ : f ⁻¹' {x} = univ
⊢ MeasurableSet univ

tactic: ext1 y
state_before: α✝ : Type ?u.13198
β✝ : Type ?u.13201
γ : Type ?u.13204
ι : Type ?u.13207
inst✝³ : Countable ι
α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace β
inst✝ : Subsingleton β
f : α → β
x : β
⊢ f ⁻¹' {x} = univ

tactic: simp
state_before: case h
α✝ : Type ?u.13198
β✝ : Type ?u.13201
γ : Type ?u.13204
ι : Type ?u.13207
inst✝³ : Countable ι
α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace β
inst✝ : Subsingleton β
f : α → β
x : β
y : α
⊢ y ∈ f ⁻¹' {x} ↔ y ∈ univ
Theorem: CategoryTheory.Limits.inr_of_isLimit
File: Mathlib/CategoryTheory/Preadditive/Biproducts.lean

tactic: apply ht.uniq (BinaryFan.mk 0 (𝟙 Y))
state_before: C : Type u
inst✝² : Category C
inst✝¹ : Preadditive C
J : Type
inst✝ : Fintype J
X Y : C
t : BinaryBicone X Y
ht : IsLimit (BinaryBicone.toCone t)
⊢ t.inr = IsLimit.lift ht (BinaryFan.mk 0 (𝟙 Y))

tactic: rintro ⟨⟨⟩⟩ <;> dsimp <;> simp
state_before: case x
C : Type u
inst✝² : Category C
inst✝¹ : Preadditive C
J : Type
inst✝ : Fintype J
X Y : C
t : BinaryBicone X Y
ht : IsLimit (BinaryBicone.toCone t)
⊢ ∀ (j : Discrete WalkingPair), t.inr ≫ (BinaryBicone.toCone t).π.app j = (BinaryFan.mk 0 (𝟙 Y)).π.app j
Theorem: map_mul_right_nhds_one
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : TopologicalSpace α
f : α → G
s : Set α
x✝ : α
x : G
⊢ map (fun y => y * x) (𝓝 1) = 𝓝 x
Theorem: Function.extend_injective
File: Mathlib/Logic/Function/Basic.lean

tactic: intro g₁ g₂ hg
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
hf : Injective f
e' : β → γ
⊢ Injective fun g => extend f g e'

tactic: refine' funext fun x ↦ _
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
hf : Injective f
e' : β → γ
g₁ g₂ : α → γ
hg : (fun g => extend f g e') g₁ = (fun g => extend f g e') g₂
⊢ g₁ = g₂

tactic: have H := congr_fun hg (f x)
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
hf : Injective f
e' : β → γ
g₁ g₂ : α → γ
hg : (fun g => extend f g e') g₁ = (fun g => extend f g e') g₂
x : α
⊢ g₁ x = g₂ x

tactic: simp only [hf.extend_apply] at H
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
hf : Injective f
e' : β → γ
g₁ g₂ : α → γ
hg : (fun g => extend f g e') g₁ = (fun g => extend f g e') g₂
x : α
H : (fun g => extend f g e') g₁ (f x) = (fun g => extend f g e') g₂ (f x)
⊢ g₁ x = g₂ x

tactic: exact H
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
hf : Injective f
e' : β → γ
g₁ g₂ : α → γ
hg : (fun g => extend f g e') g₁ = (fun g => extend f g e') g₂
x : α
H : g₁ x = g₂ x
⊢ g₁ x = g₂ x
Theorem: Real.Angle.sin_coe_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [sin_coe, Real.sin_pi]
state_before: ⊢ sin ↑π = 0
Theorem: Polynomial.mul_X_add_nat_cast_comp
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: rw [mul_add, add_comp, mul_X_comp, ← Nat.cast_comm, nat_cast_mul_comp, Nat.cast_comm, mul_add]
state_before: S : Type u
inst✝ : Semiring S
p q : S[X]
n : ℕ
⊢ comp (p * (X + ↑n)) q = comp p q * (q + ↑n)