tasksource/leandojo huggingface dataset:
Theorem: Nat.Partrec.Code.evaln_bound
File: Mathlib/Computability/PartrecCode.lean

tactic: simp [evaln] at h
state_before: c : Code
n x : ℕ
h : x ∈ evaln 0 c n
⊢ n < 0

tactic: suffices ∀ {o : Option ℕ}, x ∈ do { guard (n ≤ k); o } → n < k + 1 by
  cases c <;> rw [evaln] at h <;> exact this h
state_before: k : ℕ
c : Code
n x : ℕ
h : x ∈ evaln (k + 1) c n
⊢ n < k + 1

tactic: simpa [Bind.bind] using Nat.lt_succ_of_le
state_before: k : ℕ
c : Code
n x : ℕ
h : x ∈ evaln (k + 1) c n
⊢ ∀ {o : Option ℕ},
    (x ∈ do
        guard (n ≤ k)
        o) →
      n < k + 1

tactic: cases c <;> rw [evaln] at h <;> exact this h
state_before: k : ℕ
c : Code
n x : ℕ
h : x ∈ evaln (k + 1) c n
this :
  ∀ {o : Option ℕ},
    (x ∈ do
        guard (n ≤ k)
        o) →
      n < k + 1
⊢ n < k + 1
Theorem: TopCat.prodIsoProd_hom_apply
File: Mathlib/Topology/Category/TopCat/Limits/Products.lean

tactic: apply Prod.ext
state_before: J : Type v
inst✝ : SmallCategory J
X Y : TopCat
x : ↑(X ⨯ Y)
⊢ (forget TopCat).map (prodIsoProd X Y).hom x = ((forget TopCat).map prod.fst x, (forget TopCat).map prod.snd x)

tactic: exact ConcreteCategory.congr_hom (prodIsoProd_hom_fst X Y) x
state_before: case h₁
J : Type v
inst✝ : SmallCategory J
X Y : TopCat
x : ↑(X ⨯ Y)
⊢ ((forget TopCat).map (prodIsoProd X Y).hom x).fst =
    ((forget TopCat).map prod.fst x, (forget TopCat).map prod.snd x).fst

tactic: exact ConcreteCategory.congr_hom (prodIsoProd_hom_snd X Y) x
state_before: case h₂
J : Type v
inst✝ : SmallCategory J
X Y : TopCat
x : ↑(X ⨯ Y)
⊢ ((forget TopCat).map (prodIsoProd X Y).hom x).snd =
    ((forget TopCat).map prod.fst x, (forget TopCat).map prod.snd x).snd
Theorem: Real.sin_arccos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: by_cases hx₁ : -1 ≤ x
state_before: x : ℝ
⊢ sin (arccos x) = sqrt (1 - x ^ 2)

tactic: swap
state_before: case pos
x : ℝ
hx₁ : -1 ≤ x
⊢ sin (arccos x) = sqrt (1 - x ^ 2)

case neg
x : ℝ
hx₁ : ¬-1 ≤ x
⊢ sin (arccos x) = sqrt (1 - x ^ 2)

tactic: by_cases hx₂ : x ≤ 1
state_before: case pos
x : ℝ
hx₁ : -1 ≤ x
⊢ sin (arccos x) = sqrt (1 - x ^ 2)

tactic: swap
state_before: case pos
x : ℝ
hx₁ : -1 ≤ x
hx₂ : x ≤ 1
⊢ sin (arccos x) = sqrt (1 - x ^ 2)

case neg
x : ℝ
hx₁ : -1 ≤ x
hx₂ : ¬x ≤ 1
⊢ sin (arccos x) = sqrt (1 - x ^ 2)

tactic: rw [arccos_eq_pi_div_two_sub_arcsin, sin_pi_div_two_sub, cos_arcsin]
state_before: case pos
x : ℝ
hx₁ : -1 ≤ x
hx₂ : x ≤ 1
⊢ sin (arccos x) = sqrt (1 - x ^ 2)

tactic: rw [not_le] at hx₁
state_before: case neg
x : ℝ
hx₁ : ¬-1 ≤ x
⊢ sin (arccos x) = sqrt (1 - x ^ 2)

tactic: rw [arccos_of_le_neg_one hx₁.le, sin_pi, sqrt_eq_zero_of_nonpos]
state_before: case neg
x : ℝ
hx₁ : x < -1
⊢ sin (arccos x) = sqrt (1 - x ^ 2)

tactic: nlinarith
state_before: case neg
x : ℝ
hx₁ : x < -1
⊢ 1 - x ^ 2 ≤ 0

tactic: rw [not_le] at hx₂
state_before: case neg
x : ℝ
hx₁ : -1 ≤ x
hx₂ : ¬x ≤ 1
⊢ sin (arccos x) = sqrt (1 - x ^ 2)

tactic: rw [arccos_of_one_le hx₂.le, sin_zero, sqrt_eq_zero_of_nonpos]
state_before: case neg
x : ℝ
hx₁ : -1 ≤ x
hx₂ : 1 < x
⊢ sin (arccos x) = sqrt (1 - x ^ 2)

tactic: nlinarith
state_before: case neg
x : ℝ
hx₁ : -1 ≤ x
hx₂ : 1 < x
⊢ 1 - x ^ 2 ≤ 0
Theorem: zpow_eq_mod_card
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [zpow_eq_mod_orderOf, ← Int.emod_emod_of_dvd n (Int.coe_nat_dvd.2 orderOf_dvd_card_univ), ←
  zpow_eq_mod_orderOf]
state_before: G : Type u
A : Type v
x y : G
a b : A
n✝ m : ℕ
inst✝² : Group G
inst✝¹ : AddGroup A
inst✝ : Fintype G
n : ℤ
⊢ x ^ n = x ^ (n % ↑(Fintype.card G))
Theorem: CategoryTheory.HasLiftingProperty.unop
File: Mathlib/CategoryTheory/LiftingProperties/Basic.lean

tactic: rw [CommSq.HasLift.iff_op]
state_before: C : Type u_1
inst✝ : Category C
A✝ B✝ B' X✝ Y✝ Y' : C
i✝ : A✝ ⟶ B✝
i' : B✝ ⟶ B'
p✝ : X✝ ⟶ Y✝
p' : Y✝ ⟶ Y'
A B X Y : Cᵒᵖ
i : A ⟶ B
p : X ⟶ Y
h : HasLiftingProperty i p
f : Y.unop ⟶ B.unop
g : X.unop ⟶ A.unop
sq : CommSq f p.unop i.unop g
⊢ CommSq.HasLift sq

tactic: simp only [Quiver.Hom.op_unop]
state_before: C : Type u_1
inst✝ : Category C
A✝ B✝ B' X✝ Y✝ Y' : C
i✝ : A✝ ⟶ B✝
i' : B✝ ⟶ B'
p✝ : X✝ ⟶ Y✝
p' : Y✝ ⟶ Y'
A B X Y : Cᵒᵖ
i : A ⟶ B
p : X ⟶ Y
h : HasLiftingProperty i p
f : Y.unop ⟶ B.unop
g : X.unop ⟶ A.unop
sq : CommSq f p.unop i.unop g
⊢ CommSq.HasLift (_ : CommSq g.op i.unop.op p.unop.op f.op)

tactic: infer_instance
state_before: C : Type u_1
inst✝ : Category C
A✝ B✝ B' X✝ Y✝ Y' : C
i✝ : A✝ ⟶ B✝
i' : B✝ ⟶ B'
p✝ : X✝ ⟶ Y✝
p' : Y✝ ⟶ Y'
A B X Y : Cᵒᵖ
i : A ⟶ B
p : X ⟶ Y
h : HasLiftingProperty i p
f : Y.unop ⟶ B.unop
g : X.unop ⟶ A.unop
sq : CommSq f p.unop i.unop g
⊢ CommSq.HasLift (_ : CommSq g.op i p f.op)
Theorem: eq_empty_relation
File: Mathlib/Order/RelClasses.lean

tactic: simpa using not_rel_of_subsingleton r
state_before: α : Type u
β : Type v
r✝ : α → α → Prop
s : β → β → Prop
r : α → α → Prop
inst✝¹ : IsIrrefl α r
inst✝ : Subsingleton α
⊢ ∀ (a b : α), r a b = EmptyRelation a b
Theorem: CategoryTheory.Limits.biprod.map_lift_mapBiprod
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Biproducts.lean

tactic: apply biprod.hom_ext <;> simp [mapBiprod, ← F.map_comp]
state_before: C : Type u₁
inst✝⁶ : Category C
D : Type u₂
inst✝⁵ : Category D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
F : C ⥤ D
inst✝² : PreservesZeroMorphisms F
X Y : C
inst✝¹ : HasBinaryBiproduct X Y
inst✝ : PreservesBinaryBiproduct X Y F
W : C
f : W ⟶ X
g : W ⟶ Y
⊢ F.map (lift f g) ≫ (mapBiprod F X Y).hom = lift (F.map f) (F.map g)
Theorem: CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation_ι_inv
File: Mathlib/CategoryTheory/Limits/FunctorCategory.lean

tactic: dsimp [colimitObjIsoColimitCompEvaluation]
state_before: C : Type u
inst✝⁴ : Category C
D : Type u'
inst✝³ : Category D
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
inst✝ : HasColimitsOfShape J C
F : J ⥤ K ⥤ C
j : J
k : K
⊢ colimit.ι (F ⋙ (evaluation K C).obj k) j ≫ (colimitObjIsoColimitCompEvaluation F k).inv = (colimit.ι F j).app k

tactic: simp
state_before: C : Type u
inst✝⁴ : Category C
D : Type u'
inst✝³ : Category D
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
inst✝ : HasColimitsOfShape J C
F : J ⥤ K ⥤ C
j : J
k : K
⊢ colimit.ι (F ⋙ (evaluation K C).obj k) j ≫ (preservesColimitIso ((evaluation K C).obj k) F).inv =
    (colimit.ι F j).app k
Theorem: Bornology.isBounded_empty
File: Mathlib/Topology/Bornology/Basic.lean

tactic: rw [isBounded_def, compl_empty]
state_before: ι : Type ?u.4271
α : Type u_1
β : Type ?u.4277
inst✝ : Bornology α
s t : Set α
x : α
⊢ IsBounded ∅

tactic: exact univ_mem
state_before: ι : Type ?u.4271
α : Type u_1
β : Type ?u.4277
inst✝ : Bornology α
s t : Set α
x : α
⊢ univ ∈ cobounded α
Theorem: Int.natAbs_inj_of_nonneg_of_nonneg
File: Mathlib/Data/Int/Lemmas.lean

tactic: rw [← sq_eq_sq ha hb, ← natAbs_eq_iff_sq_eq]
state_before: a✝ b✝ : ℤ
n : ℕ
a b : ℤ
ha : 0 ≤ a
hb : 0 ≤ b
⊢ natAbs a = natAbs b ↔ a = b
Theorem: List.takeD_nil
File: Std/Data/List/Basic.lean

tactic: induction n <;> simp [*]
state_before: α : Type u_1
n : Nat
a : α
⊢ takeD n [] a = replicate n a
Theorem: Multiset.map_add_right_Ioo
File: Mathlib/Data/Multiset/LocallyFinite.lean

tactic: simp_rw [add_comm _ c]
state_before: α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (fun x => x + c) (Ioo a b) = Ioo (a + c) (b + c)

tactic: exact map_add_left_Ioo _ _ _
state_before: α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (fun x => c + x) (Ioo a b) = Ioo (c + a) (c + b)
Theorem: MonoidHom.functions_ext
File: Mathlib/Algebra/BigOperators/Pi.lean

tactic: cases nonempty_fintype I
state_before: I : Type u_1
inst✝³ : DecidableEq I
Z : I → Type u_3
inst✝² : (i : I) → CommMonoid (Z i)
inst✝¹ : Finite I
G : Type u_2
inst✝ : CommMonoid G
g h : ((i : I) → Z i) →* G
H : ∀ (i : I) (x : Z i), ↑g (Pi.mulSingle i x) = ↑h (Pi.mulSingle i x)
⊢ g = h

tactic: ext k
state_before: case intro
I : Type u_1
inst✝³ : DecidableEq I
Z : I → Type u_3
inst✝² : (i : I) → CommMonoid (Z i)
inst✝¹ : Finite I
G : Type u_2
inst✝ : CommMonoid G
g h : ((i : I) → Z i) →* G
H : ∀ (i : I) (x : Z i), ↑g (Pi.mulSingle i x) = ↑h (Pi.mulSingle i x)
val✝ : Fintype I
⊢ g = h

tactic: rw [← Finset.univ_prod_mulSingle k, g.map_prod, h.map_prod]
state_before: case intro.h
I : Type u_1
inst✝³ : DecidableEq I
Z : I → Type u_3
inst✝² : (i : I) → CommMonoid (Z i)
inst✝¹ : Finite I
G : Type u_2
inst✝ : CommMonoid G
g h : ((i : I) → Z i) →* G
H : ∀ (i : I) (x : Z i), ↑g (Pi.mulSingle i x) = ↑h (Pi.mulSingle i x)
val✝ : Fintype I
k : (i : I) → Z i
⊢ ↑g k = ↑h k

tactic: simp only [H]
state_before: case intro.h
I : Type u_1
inst✝³ : DecidableEq I
Z : I → Type u_3
inst✝² : (i : I) → CommMonoid (Z i)
inst✝¹ : Finite I
G : Type u_2
inst✝ : CommMonoid G
g h : ((i : I) → Z i) →* G
H : ∀ (i : I) (x : Z i), ↑g (Pi.mulSingle i x) = ↑h (Pi.mulSingle i x)
val✝ : Fintype I
k : (i : I) → Z i
⊢ ∏ x : I, ↑g (Pi.mulSingle x (k x)) = ∏ x : I, ↑h (Pi.mulSingle x (k x))
Theorem: Continuous.range_subset_closure_image_dense
File: Mathlib/Topology/Basic.lean

tactic: rw [← image_univ, ← hs.closure_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.175018
δ : Type ?u.175021
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
κ : Type ?u.175033
ι : Type ?u.175036
f✝ : κ → β
g : β → γ
f : α → β
hf : Continuous f
s : Set α
hs : Dense s
⊢ range f ⊆ closure (f '' s)

tactic: exact image_closure_subset_closure_image hf
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.175018
δ : Type ?u.175021
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
κ : Type ?u.175033
ι : Type ?u.175036
f✝ : κ → β
g : β → γ
f : α → β
hf : Continuous f
s : Set α
hs : Dense s
⊢ f '' closure s ⊆ closure (f '' s)
Theorem: Filter.frequently_atTop'
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp
state_before: ι : Type ?u.35304
ι' : Type ?u.35307
α : Type u_1
β : Type ?u.35313
γ : Type ?u.35316
inst✝² : SemilatticeSup α
inst✝¹ : Nonempty α
inst✝ : NoMaxOrder α
p : α → Prop
⊢ (∀ (i : α), True → ∃ x, x ∈ Ioi i ∧ p x) ↔ ∀ (a : α), ∃ b, b > a ∧ p b
Theorem: Set.OrdConnected.interior
File: Mathlib/Topology/Algebra/Order/UpperLower.lean

tactic: rw [← h.upperClosure_inter_lowerClosure, interior_inter]
state_before: α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : Preorder α
inst✝ : HasUpperLowerClosure α
s : Set α
h : OrdConnected s
⊢ OrdConnected (interior s)

tactic: exact
  (upperClosure s).upper.interior.ordConnected.inter (lowerClosure s).lower.interior.ordConnected
state_before: α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : Preorder α
inst✝ : HasUpperLowerClosure α
s : Set α
h : OrdConnected s
⊢ OrdConnected (interior ↑(upperClosure s) ∩ interior ↑(lowerClosure s))
Theorem: MvPowerSeries.trunc_one
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [coeff_trunc, coeff_one]
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n✝ n : σ →₀ ℕ
hnn : n ≠ 0
m : σ →₀ ℕ
⊢ MvPolynomial.coeff m (↑(trunc R n) 1) = MvPolynomial.coeff m 1

tactic: split_ifs with H H'
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n✝ n : σ →₀ ℕ
hnn : n ≠ 0
m : σ →₀ ℕ
⊢ (if m < n then if m = 0 then 1 else 0 else 0) = MvPolynomial.coeff m 1

tactic: subst m
state_before: case inl.inl
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n✝ n : σ →₀ ℕ
hnn : n ≠ 0
m : σ →₀ ℕ
H : m < n
H' : m = 0
⊢ 1 = MvPolynomial.coeff m 1

tactic: simp
state_before: case inl.inl
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n✝ n : σ →₀ ℕ
hnn : n ≠ 0
H : 0 < n
⊢ 1 = MvPolynomial.coeff 0 1

tactic: symm
state_before: case inl.inr
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n✝ n : σ →₀ ℕ
hnn : n ≠ 0
m : σ →₀ ℕ
H : m < n
H' : ¬m = 0
⊢ 0 = MvPolynomial.coeff m 1

tactic: rw [MvPolynomial.coeff_one]
state_before: case inl.inr
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n✝ n : σ →₀ ℕ
hnn : n ≠ 0
m : σ →₀ ℕ
H : m < n
H' : ¬m = 0
⊢ MvPolynomial.coeff m 1 = 0

tactic: exact if_neg (Ne.symm H')
state_before: case inl.inr
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n✝ n : σ →₀ ℕ
hnn : n ≠ 0
m : σ →₀ ℕ
H : m < n
H' : ¬m = 0
⊢ (if 0 = m then 1 else 0) = 0

tactic: symm
state_before: case inr
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n✝ n : σ →₀ ℕ
hnn : n ≠ 0
m : σ →₀ ℕ
H : ¬m < n
⊢ 0 = MvPolynomial.coeff m 1

tactic: rw [MvPolynomial.coeff_one]
state_before: case inr
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n✝ n : σ →₀ ℕ
hnn : n ≠ 0
m : σ →₀ ℕ
H : ¬m < n
⊢ MvPolynomial.coeff m 1 = 0

tactic: refine' if_neg _
state_before: case inr
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n✝ n : σ →₀ ℕ
hnn : n ≠ 0
m : σ →₀ ℕ
H : ¬m < n
⊢ (if 0 = m then 1 else 0) = 0

tactic: rintro rfl
state_before: case inr
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n✝ n : σ →₀ ℕ
hnn : n ≠ 0
m : σ →₀ ℕ
H : ¬m < n
⊢ ¬0 = m

tactic: apply H
state_before: case inr
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n✝ n : σ →₀ ℕ
hnn : n ≠ 0
H : ¬0 < n
⊢ False

tactic: exact Ne.bot_lt hnn
state_before: case inr
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n✝ n : σ →₀ ℕ
hnn : n ≠ 0
H : ¬0 < n
⊢ 0 < n
Theorem: EMetric.mem_closure_iff
File: Mathlib/Topology/MetricSpace/EMetricSpace.lean

tactic: simp only [mem_ball, edist_comm x]
state_before: α : Type u
β : Type v
X : Type ?u.222978
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t : Set α
⊢ (∀ (i : ℝ≥0∞), 0 < i → ∃ y, y ∈ s ∧ y ∈ ball x i) ↔ ∀ (ε : ℝ≥0∞), ε > 0 → ∃ y, y ∈ s ∧ edist x y < ε
Theorem: multiplicity.finite_int_iff_natAbs_finite
File: Mathlib/RingTheory/Int/Basic.lean

tactic: simp only [finite_def, ← Int.natAbs_dvd_natAbs, Int.natAbs_pow]
state_before: a b : ℤ
⊢ Finite a b ↔ Finite (_root_.Int.natAbs a) (_root_.Int.natAbs b)
Theorem: MeasureTheory.setToFun_smul_left'
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: by_cases hf : Integrable f μ
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1373587
G : Type ?u.1373590
𝕜 : Type ?u.1373593
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 α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
c : ℝ
h_smul : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → T' s = c • T s
f : α → E
⊢ setToFun μ T' hT' f = c • setToFun μ T hT f

tactic: simp_rw [setToFun_eq _ hf, L1.setToL1_smul_left' hT hT' c h_smul]
state_before: case pos
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1373587
G : Type ?u.1373590
𝕜 : Type ?u.1373593
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 α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
c : ℝ
h_smul : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → T' s = c • T s
f : α → E
hf : Integrable f
⊢ setToFun μ T' hT' f = c • setToFun μ T hT f

tactic: simp_rw [setToFun_undef _ hf, smul_zero]
state_before: case neg
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1373587
G : Type ?u.1373590
𝕜 : Type ?u.1373593
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 α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
c : ℝ
h_smul : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → T' s = c • T s
f : α → E
hf : ¬Integrable f
⊢ setToFun μ T' hT' f = c • setToFun μ T hT f
Theorem: Ordinal.deriv_eq_id_of_nfp_eq_id
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: simp [h]
state_before: f✝ : Ordinal → Ordinal
f : Ordinal → Ordinal
h : nfp f = id
⊢ deriv f 0 = id 0 ∧ ∀ (a : Ordinal), deriv f a = id a → deriv f (succ a) = id (succ a)
Theorem: closedBall_one_div_singleton
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: simp
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ closedBall 1 δ / {x} = closedBall x⁻¹ δ
Theorem: CategoryTheory.Bicategory.pentagon_inv_inv_hom_inv_inv
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h : c ⟶ d
i : d ⟶ e
⊢ inv ((α_ f g (h ≫ i)).inv ≫ (α_ (f ≫ g) h i).inv ≫ (α_ f g h).hom ▷ i) =
    inv (f ◁ (α_ g h i).inv ≫ (α_ f (g ≫ h) i).inv)
Theorem: MeasureTheory.SimpleFunc.integral_const
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: classical
calc
  (const α y).integral μ = ∑ z in {y}, (μ (const α y ⁻¹' {z})).toReal • z :=
    integral_eq_sum_of_subset <| (filter_subset _ _).trans (range_const_subset _ _)
  _ = (μ univ).toReal • y := by simp [Set.preimage]
state_before: α : Type u_1
E : Type ?u.116296
F : Type u_2
𝕜 : Type ?u.116302
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
p : ℝ≥0∞
G : Type ?u.116404
F' : Type ?u.116407
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedAddCommGroup F'
inst✝ : NormedSpace ℝ F'
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
y : F
⊢ integral μ (const α y) = ENNReal.toReal (↑↑μ Set.univ) • y

tactic: calc
  (const α y).integral μ = ∑ z in {y}, (μ (const α y ⁻¹' {z})).toReal • z :=
    integral_eq_sum_of_subset <| (filter_subset _ _).trans (range_const_subset _ _)
  _ = (μ univ).toReal • y := by simp [Set.preimage]
state_before: α : Type u_1
E : Type ?u.116296
F : Type u_2
𝕜 : Type ?u.116302
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
p : ℝ≥0∞
G : Type ?u.116404
F' : Type ?u.116407
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedAddCommGroup F'
inst✝ : NormedSpace ℝ F'
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
y : F
⊢ integral μ (const α y) = ENNReal.toReal (↑↑μ Set.univ) • y

tactic: simp [Set.preimage]
state_before: α : Type u_1
E : Type ?u.116296
F : Type u_2
𝕜 : Type ?u.116302
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
p : ℝ≥0∞
G : Type ?u.116404
F' : Type ?u.116407
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedAddCommGroup F'
inst✝ : NormedSpace ℝ F'
m✝ : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ : Measure α
y : F
⊢ ∑ z in {y}, ENNReal.toReal (↑↑μ (↑(const α y) ⁻¹' {z})) • z = ENNReal.toReal (↑↑μ Set.univ) • y
Theorem: Int.emod_self
File: Std/Data/Int/DivMod.lean

tactic: have := mul_emod_left 1 a
state_before: a : Int
⊢ a % a = 0

tactic: rwa [Int.one_mul] at this
state_before: a : Int
this : 1 * a % a = 0
⊢ a % a = 0
Theorem: MeasureTheory.Measure.sum_prod
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: refine' prod_eq fun s t hs ht => _
state_before: α : Type u_2
α' : Type ?u.4494925
β : Type u_3
β' : Type ?u.4494931
γ : Type ?u.4494934
E : Type ?u.4494937
inst✝⁹ : MeasurableSpace α
inst✝⁸ : MeasurableSpace α'
inst✝⁷ : MeasurableSpace β
inst✝⁶ : MeasurableSpace β'
inst✝⁵ : MeasurableSpace γ
μ✝ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝⁴ : NormedAddCommGroup E
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ✝
ι : Type u_1
inst✝¹ : Finite ι
μ : ι → Measure α
inst✝ : ∀ (i : ι), SigmaFinite (μ i)
⊢ Measure.prod (sum μ) ν = sum fun i => Measure.prod (μ i) ν

tactic: simp_rw [sum_apply _ (hs.prod ht), sum_apply _ hs, prod_prod, ENNReal.tsum_mul_right]
state_before: α : Type u_2
α' : Type ?u.4494925
β : Type u_3
β' : Type ?u.4494931
γ : Type ?u.4494934
E : Type ?u.4494937
inst✝⁹ : MeasurableSpace α
inst✝⁸ : MeasurableSpace α'
inst✝⁷ : MeasurableSpace β
inst✝⁶ : MeasurableSpace β'
inst✝⁵ : MeasurableSpace γ
μ✝ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝⁴ : NormedAddCommGroup E
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ✝
ι : Type u_1
inst✝¹ : Finite ι
μ : ι → Measure α
inst✝ : ∀ (i : ι), SigmaFinite (μ i)
s : Set α
t : Set β
hs : MeasurableSet s
ht : MeasurableSet t
⊢ ↑↑(sum fun i => Measure.prod (μ i) ν) (s ×ˢ t) = ↑↑(sum μ) s * ↑↑ν t
Theorem: tendstoUniformly_tsum
File: Mathlib/Analysis/Calculus/Series.lean

tactic: rw [← tendstoUniformlyOn_univ]
state_before: α : Type u_1
β : Type u_3
𝕜 : Type ?u.6502
E : Type ?u.6505
F : Type u_2
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : CompleteSpace F
u : α → ℝ
f : α → β → F
hu : Summable u
hfu : ∀ (n : α) (x : β), ‖f n x‖ ≤ u n
⊢ TendstoUniformly (fun t x => ∑ n in t, f n x) (fun x => ∑' (n : α), f n x) atTop

tactic: exact tendstoUniformlyOn_tsum hu fun n x _ => hfu n x
state_before: α : Type u_1
β : Type u_3
𝕜 : Type ?u.6502
E : Type ?u.6505
F : Type u_2
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : CompleteSpace F
u : α → ℝ
f : α → β → F
hu : Summable u
hfu : ∀ (n : α) (x : β), ‖f n x‖ ≤ u n
⊢ TendstoUniformlyOn (fun t x => ∑ n in t, f n x) (fun x => ∑' (n : α), f n x) atTop univ
Theorem: SimpleGraph.IsRegularOfDegree.top
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: intro v
state_before: ι : Sort ?u.287669
𝕜 : Type ?u.287672
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableEq V
⊢ IsRegularOfDegree ⊤ (Fintype.card V - 1)

tactic: simp
state_before: ι : Sort ?u.287669
𝕜 : Type ?u.287672
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w : V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableEq V
v : V
⊢ degree ⊤ v = Fintype.card V - 1
Theorem: MeasurableEquiv.quasiMeasurePreserving_symm
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [Measure.map_map, e.symm_comp_self, Measure.map_id] <;> measurability
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.3211462
δ : Type ?u.3211465
ι : Type ?u.3211468
R : Type ?u.3211471
R' : Type ?u.3211474
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
μ✝ : MeasureTheory.Measure α
ν : MeasureTheory.Measure β
μ : MeasureTheory.Measure α
e : α ≃ᵐ β
⊢ Measure.map (↑(symm e)) (Measure.map (↑e) μ) ≪ μ
Theorem: abs_max_sub_max_le_abs
File: Mathlib/Algebra/Order/Group/MinMax.lean

tactic: simpa only [sub_self, abs_zero, max_eq_left (abs_nonneg (a - b))]
  using abs_max_sub_max_le_max a c b c
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c✝ a b c : α
⊢ abs (max a c - max b c) ≤ abs (a - b)
Theorem: Subgroup.pi_empty
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: simp [mem_pi]
state_before: G : Type ?u.318819
G' : Type ?u.318822
inst✝⁵ : Group G
inst✝⁴ : Group G'
A : Type ?u.318831
inst✝³ : AddGroup A
H✝ K : Subgroup G
k : Set G
N : Type ?u.318852
inst✝² : Group N
P : Type ?u.318858
inst✝¹ : Group P
η : Type u_2
f : η → Type u_1
inst✝ : (i : η) → Group (f i)
H : (i : η) → Subgroup (f i)
x : (i : η) → f i
⊢ x ∈ pi ∅ H ↔ x ∈ ⊤
Theorem: Real.Angle.sin_add_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: induction θ using Real.Angle.induction_on
state_before: θ : Angle
⊢ sin (θ + ↑(π / 2)) = cos θ

tactic: exact Real.sin_add_pi_div_two _
state_before: case h
x✝ : ℝ
⊢ sin (↑x✝ + ↑(π / 2)) = cos ↑x✝
Theorem: InnerProductGeometry.continuousAt_angle
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: simp [hx1, hx2]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y : V
x : V × V
hx1 : x.fst ≠ 0
hx2 : x.snd ≠ 0
⊢ ‖x.fst‖ * ‖x.snd‖ ≠ 0