tasksource/leandojo huggingface dataset:
Theorem: AlgebraicTopology.DoldKan.factors_normalizedMooreComplex_PInfty
File: Mathlib/AlgebraicTopology/DoldKan/Normalized.lean

tactic: rcases n with _|n
state_before: A : Type u_2
inst✝¹ : Category A
inst✝ : Abelian A
X : SimplicialObject A
n : ℕ
⊢ Factors (NormalizedMooreComplex.objX X n) (HomologicalComplex.Hom.f PInfty n)

tactic: apply top_factors
state_before: case zero
A : Type u_2
inst✝¹ : Category A
inst✝ : Abelian A
X : SimplicialObject A
⊢ Factors (NormalizedMooreComplex.objX X Nat.zero) (HomologicalComplex.Hom.f PInfty Nat.zero)

tactic: rw [PInfty_f, NormalizedMooreComplex.objX, finset_inf_factors]
state_before: case succ
A : Type u_2
inst✝¹ : Category A
inst✝ : Abelian A
X : SimplicialObject A
n : ℕ
⊢ Factors (NormalizedMooreComplex.objX X (Nat.succ n)) (HomologicalComplex.Hom.f PInfty (Nat.succ n))

tactic: intro i _
state_before: case succ
A : Type u_2
inst✝¹ : Category A
inst✝ : Abelian A
X : SimplicialObject A
n : ℕ
⊢ ∀ (i : Fin (n + 1)),
    i ∈ Finset.univ →
      Factors (kernelSubobject (SimplicialObject.δ X (Fin.succ i)))
        (HomologicalComplex.Hom.f (P (Nat.succ n)) (Nat.succ n))

tactic: apply kernelSubobject_factors
state_before: case succ
A : Type u_2
inst✝¹ : Category A
inst✝ : Abelian A
X : SimplicialObject A
n : ℕ
i : Fin (n + 1)
a✝ : i ∈ Finset.univ
⊢ Factors (kernelSubobject (SimplicialObject.δ X (Fin.succ i))) (HomologicalComplex.Hom.f (P (Nat.succ n)) (Nat.succ n))

tactic: exact (HigherFacesVanish.of_P (n + 1) n) i le_add_self
state_before: case succ.w
A : Type u_2
inst✝¹ : Category A
inst✝ : Abelian A
X : SimplicialObject A
n : ℕ
i : Fin (n + 1)
a✝ : i ∈ Finset.univ
⊢ HomologicalComplex.Hom.f (P (Nat.succ n)) (Nat.succ n) ≫ SimplicialObject.δ X (Fin.succ i) = 0
Theorem: MeasureTheory.FiniteMeasure.tendsto_iff_forall_toWeakDualBCNN_tendsto
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: rw [tendsto_iff_weak_star_tendsto, tendsto_iff_forall_eval_tendsto_topDualPairing]
state_before: Ω : Type u_2
inst✝⁶ : MeasurableSpace Ω
R : Type ?u.130020
inst✝⁵ : SMul R ℝ≥0
inst✝⁴ : SMul R ℝ≥0∞
inst✝³ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_1
F : Filter γ
μs : γ → FiniteMeasure Ω
μ : FiniteMeasure Ω
⊢ Tendsto μs F (𝓝 μ) ↔ ∀ (f : Ω →ᵇ ℝ≥0), Tendsto (fun i => ↑(toWeakDualBCNN (μs i)) f) F (𝓝 (↑(toWeakDualBCNN μ) f))

tactic: rfl
state_before: Ω : Type u_2
inst✝⁶ : MeasurableSpace Ω
R : Type ?u.130020
inst✝⁵ : SMul R ℝ≥0
inst✝⁴ : SMul R ℝ≥0∞
inst✝³ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_1
F : Filter γ
μs : γ → FiniteMeasure Ω
μ : FiniteMeasure Ω
⊢ (∀ (y : Ω →ᵇ ℝ≥0),
      Tendsto (fun i => ↑(↑(topDualPairing ℝ≥0 (Ω →ᵇ ℝ≥0)) (toWeakDualBCNN (μs i))) y) F
        (𝓝 (↑(↑(topDualPairing ℝ≥0 (Ω →ᵇ ℝ≥0)) (toWeakDualBCNN μ)) y))) ↔
    ∀ (f : Ω →ᵇ ℝ≥0), Tendsto (fun i => ↑(toWeakDualBCNN (μs i)) f) F (𝓝 (↑(toWeakDualBCNN μ) f))
Theorem: sSup_sUnion
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [sUnion_eq_biUnion, sSup_eq_iSup, iSup_iUnion]
state_before: α : Type ?u.306093
β : Type u_1
γ : Type ?u.306099
ι : Sort ?u.306102
ι' : Sort ?u.306105
ι₂ : Sort ?u.306108
κ : ι → Sort ?u.306113
κ₁ : ι → Sort ?u.306118
κ₂ : ι → Sort ?u.306123
κ' : ι' → Sort ?u.306128
inst✝ : CompleteLattice β
s : Set (Set β)
⊢ sSup (⋃₀ s) = ⨆ (t : Set β) (_ : t ∈ s), sSup t
Theorem: AffineBasis.det_smul_coords_eq_cramer_coords
File: Mathlib/LinearAlgebra/AffineSpace/Matrix.lean

tactic: have hu := b.isUnit_toMatrix b₂
state_before: ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : CommRing k
inst✝² : Module k V
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
b b₂ : AffineBasis ι k P
x : P
⊢ det (toMatrix b ↑b₂) • ↑(coords b₂) x = ↑(cramer (toMatrix b ↑b₂)ᵀ) (↑(coords b) x)

tactic: rw [Matrix.isUnit_iff_isUnit_det] at hu
state_before: ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : CommRing k
inst✝² : Module k V
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
b b₂ : AffineBasis ι k P
x : P
hu : IsUnit (toMatrix b ↑b₂)
⊢ det (toMatrix b ↑b₂) • ↑(coords b₂) x = ↑(cramer (toMatrix b ↑b₂)ᵀ) (↑(coords b) x)

tactic: rw [← b.toMatrix_inv_vecMul_toMatrix, Matrix.det_smul_inv_vecMul_eq_cramer_transpose _ _ hu]
state_before: ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : CommRing k
inst✝² : Module k V
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
b b₂ : AffineBasis ι k P
x : P
hu : IsUnit (det (toMatrix b ↑b₂))
⊢ det (toMatrix b ↑b₂) • ↑(coords b₂) x = ↑(cramer (toMatrix b ↑b₂)ᵀ) (↑(coords b) x)
Theorem: commute_star_comm
File: Mathlib/Algebra/Star/Basic.lean

tactic: rw [← commute_star_star, star_star]
state_before: R : Type u
inst✝¹ : Semigroup R
inst✝ : StarSemigroup R
x y : R
⊢ Commute (star x) y ↔ Commute x (star y)
Theorem: Set.image2_union_left
File: Mathlib/Data/Set/NAry.lean

tactic: ext c
state_before: α : Type u_2
α' : Type ?u.13084
β : Type u_3
β' : Type ?u.13090
γ : Type u_1
γ' : Type ?u.13096
δ : Type ?u.13099
δ' : Type ?u.13102
ε : Type ?u.13105
ε' : Type ?u.13108
ζ : Type ?u.13111
ζ' : Type ?u.13114
ν : Type ?u.13117
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ image2 f (s ∪ s') t = image2 f s t ∪ image2 f s' t

tactic: constructor
state_before: case h
α : Type u_2
α' : Type ?u.13084
β : Type u_3
β' : Type ?u.13090
γ : Type u_1
γ' : Type ?u.13096
δ : Type ?u.13099
δ' : Type ?u.13102
ε : Type ?u.13105
ε' : Type ?u.13108
ζ : Type ?u.13111
ζ' : Type ?u.13114
ν : Type ?u.13117
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c✝ c' : γ
d d' : δ
c : γ
⊢ c ∈ image2 f (s ∪ s') t ↔ c ∈ image2 f s t ∪ image2 f s' t

tactic: rintro ⟨a, b, ha | ha, hb, rfl⟩ <;> [left; right] <;> exact ⟨_, _, ‹_›, ‹_›, rfl⟩
state_before: case h.mp
α : Type u_2
α' : Type ?u.13084
β : Type u_3
β' : Type ?u.13090
γ : Type u_1
γ' : Type ?u.13096
δ : Type ?u.13099
δ' : Type ?u.13102
ε : Type ?u.13105
ε' : Type ?u.13108
ζ : Type ?u.13111
ζ' : Type ?u.13114
ν : Type ?u.13117
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c✝ c' : γ
d d' : δ
c : γ
⊢ c ∈ image2 f (s ∪ s') t → c ∈ image2 f s t ∪ image2 f s' t

tactic: rintro (⟨_, _, _, _, rfl⟩ | ⟨_, _, _, _, rfl⟩) <;> refine' ⟨_, _, _, ‹_›, rfl⟩ <;>
  simp [mem_union, *]
state_before: case h.mpr
α : Type u_2
α' : Type ?u.13084
β : Type u_3
β' : Type ?u.13090
γ : Type u_1
γ' : Type ?u.13096
δ : Type ?u.13099
δ' : Type ?u.13102
ε : Type ?u.13105
ε' : Type ?u.13108
ζ : Type ?u.13111
ζ' : Type ?u.13114
ν : Type ?u.13117
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c✝ c' : γ
d d' : δ
c : γ
⊢ c ∈ image2 f s t ∪ image2 f s' t → c ∈ image2 f (s ∪ s') t
Theorem: Equiv.Perm.sign_eq_sign_of_equiv
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: have hg : g = (e.symm.trans f).trans e := Equiv.ext <| by simp [h]
state_before: α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
f : Perm α
g : Perm β
e : α ≃ β
h : ∀ (x : α), ↑e (↑f x) = ↑g (↑e x)
⊢ ↑sign f = ↑sign g

tactic: rw [hg, sign_symm_trans_trans]
state_before: α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
f : Perm α
g : Perm β
e : α ≃ β
h : ∀ (x : α), ↑e (↑f x) = ↑g (↑e x)
hg : g = (e.symm.trans f).trans e
⊢ ↑sign f = ↑sign g

tactic: simp [h]
state_before: α : Type u
β : Type v
inst✝³ : DecidableEq α
inst✝² : Fintype α
inst✝¹ : DecidableEq β
inst✝ : Fintype β
f : Perm α
g : Perm β
e : α ≃ β
h : ∀ (x : α), ↑e (↑f x) = ↑g (↑e x)
⊢ ∀ (x : β), ↑g x = ↑((e.symm.trans f).trans e) x
Theorem: PFun.fix_fwd
File: Mathlib/Data/PFun.lean

tactic: rwa [← fix_fwd_eq ha']
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.30447
δ : Type ?u.30450
ε : Type ?u.30453
ι : Type ?u.30456
f : α →. β ⊕ α
b : β
a a' : α
hb : b ∈ fix f a
ha' : Sum.inr a' ∈ f a
⊢ b ∈ fix f a'
Theorem: LaurentPolynomial.degree_C_mul_T_le
File: Mathlib/Data/Polynomial/Laurent.lean

tactic: by_cases a0 : a = 0
state_before: R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
⊢ degree (↑C a * T n) ≤ ↑n

tactic: simp only [a0, map_zero, MulZeroClass.zero_mul, degree_zero, bot_le]
state_before: case pos
R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
a0 : a = 0
⊢ degree (↑C a * T n) ≤ ↑n

tactic: exact (degree_C_mul_T n a a0).le
state_before: case neg
R : Type u_1
inst✝ : Semiring R
n : ℤ
a : R
a0 : ¬a = 0
⊢ degree (↑C a * T n) ≤ ↑n
Theorem: Quiver.Hom.cast_cast
File: Mathlib/Combinatorics/Quiver/Cast.lean

tactic: subst_vars
state_before: U : Type u_1
inst✝ : Quiver U
u v u' v' u'' v'' : U
e : u ⟶ v
hu : u = u'
hv : v = v'
hu' : u' = u''
hv' : v' = v''
⊢ cast hu' hv' (cast hu hv e) = cast (_ : u = u'') (_ : v = v'') e

tactic: rfl
state_before: U : Type u_1
inst✝ : Quiver U
u'' v'' : U
e : u'' ⟶ v''
⊢ cast (_ : u'' = u'') (_ : v'' = v'') (cast (_ : u'' = u'') (_ : v'' = v'') e) = cast (_ : u'' = u'') (_ : v'' = v'') e
Theorem: InnerProductGeometry.inner_eq_mul_norm_iff_angle_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: refine' ⟨fun h => _, inner_eq_mul_norm_of_angle_eq_zero⟩
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
⊢ inner x y = ‖x‖ * ‖y‖ ↔ angle x y = 0

tactic: have h₁ : ‖x‖ * ‖y‖ ≠ 0 := (mul_pos (norm_pos_iff.mpr hx) (norm_pos_iff.mpr hy)).ne'
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
h : inner x y = ‖x‖ * ‖y‖
⊢ angle x y = 0

tactic: rw [angle, h, div_self h₁, Real.arccos_one]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
h : inner x y = ‖x‖ * ‖y‖
h₁ : ‖x‖ * ‖y‖ ≠ 0
⊢ angle x y = 0
Theorem: Submonoid.fg_iff
File: Mathlib/GroupTheory/Finiteness.lean

tactic: simp [hS]
state_before: M : Type u_1
N : Type ?u.1028
inst✝¹ : Monoid M
inst✝ : AddMonoid N
P : Submonoid M
x✝ : ∃ S, closure S = P ∧ Set.Finite S
S : Set M
hS : closure S = P
hf : Set.Finite S
⊢ closure ↑(Set.Finite.toFinset hf) = P
Theorem: CategoryTheory.Limits.diagonalObjPullbackFstIso_inv_fst_snd
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

tactic: delta diagonalObjPullbackFstIso
state_before: C : Type u_2
inst✝⁵ : Category C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ :
  HasPullback (diagonal i)
    (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) (_ : (f✝ ≫ i) ≫ 𝟙 S = f✝ ≫ i) (_ : (g✝ ≫ i) ≫ 𝟙 S = g✝ ≫ i))
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (diagonalObjPullbackFstIso f g).inv ≫ fst ≫ snd = fst ≫ fst

tactic: simp
state_before: C : Type u_2
inst✝⁵ : Category C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ :
  HasPullback (diagonal i)
    (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) (_ : (f✝ ≫ i) ≫ 𝟙 S = f✝ ≫ i) (_ : (g✝ ≫ i) ≫ 𝟙 S = g✝ ≫ i))
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (pullbackRightPullbackFstIso f g fst ≪≫
          congrHom (_ : fst ≫ f = snd ≫ g) (_ : g = g) ≪≫
            pullbackAssoc f g g g ≪≫ pullbackSymmetry f (fst ≫ g) ≪≫ congrHom (_ : fst ≫ g = snd ≫ g) (_ : f = f)).inv ≫
      fst ≫ snd =
    fst ≫ fst
Theorem: BoxIntegral.Box.splitLower_def
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

tactic: simp only [splitLower, mk'_eq_coe, min_eq_left h.2.le, update]
state_before: ι : Type u_1
M : Type ?u.8953
n : ℕ
I : Box ι
i✝ : ι
x✝ : ℝ
y : ι → ℝ
inst✝ : DecidableEq ι
i : ι
x : ℝ
h : x ∈ Ioo (lower I i) (upper I i)
h' : optParam (∀ (j : ι), lower I j < update I.upper i x j) (_ : ∀ (x_1 : ι), lower I x_1 < update I.upper i x x_1)
⊢ splitLower I i x = ↑{ lower := I.lower, upper := update I.upper i x, lower_lt_upper := h' }
Theorem: irreducible_mul_units
File: Mathlib/Algebra/Associated.lean

tactic: simp only [irreducible_iff, Units.isUnit_mul_units, and_congr_right_iff]
state_before: α : Type u_1
β : Type ?u.91092
γ : Type ?u.91095
δ : Type ?u.91098
inst✝ : Monoid α
a : αˣ
b : α
⊢ Irreducible (b * ↑a) ↔ Irreducible b

tactic: refine' fun _ => ⟨fun h A B HAB => _, fun h A B HAB => _⟩
state_before: α : Type u_1
β : Type ?u.91092
γ : Type ?u.91095
δ : Type ?u.91098
inst✝ : Monoid α
a : αˣ
b : α
⊢ ¬IsUnit b →
    ((∀ (a_2 b_1 : α), b * ↑a = a_2 * b_1 → IsUnit a_2 ∨ IsUnit b_1) ↔
      ∀ (a b_1 : α), b = a * b_1 → IsUnit a ∨ IsUnit b_1)

tactic: rw [← Units.isUnit_mul_units B a]
state_before: case refine'_1
α : Type u_1
β : Type ?u.91092
γ : Type ?u.91095
δ : Type ?u.91098
inst✝ : Monoid α
a : αˣ
b : α
x✝ : ¬IsUnit b
h : ∀ (a_1 b_1 : α), b * ↑a = a_1 * b_1 → IsUnit a_1 ∨ IsUnit b_1
A B : α
HAB : b = A * B
⊢ IsUnit A ∨ IsUnit B

tactic: apply h
state_before: case refine'_1
α : Type u_1
β : Type ?u.91092
γ : Type ?u.91095
δ : Type ?u.91098
inst✝ : Monoid α
a : αˣ
b : α
x✝ : ¬IsUnit b
h : ∀ (a_1 b_1 : α), b * ↑a = a_1 * b_1 → IsUnit a_1 ∨ IsUnit b_1
A B : α
HAB : b = A * B
⊢ IsUnit A ∨ IsUnit (B * ↑a)

tactic: rw [← mul_assoc, ← HAB]
state_before: case refine'_1.a
α : Type u_1
β : Type ?u.91092
γ : Type ?u.91095
δ : Type ?u.91098
inst✝ : Monoid α
a : αˣ
b : α
x✝ : ¬IsUnit b
h : ∀ (a_1 b_1 : α), b * ↑a = a_1 * b_1 → IsUnit a_1 ∨ IsUnit b_1
A B : α
HAB : b = A * B
⊢ b * ↑a = A * (B * ↑a)

tactic: rw [← Units.isUnit_mul_units B a⁻¹]
state_before: case refine'_2
α : Type u_1
β : Type ?u.91092
γ : Type ?u.91095
δ : Type ?u.91098
inst✝ : Monoid α
a : αˣ
b : α
x✝ : ¬IsUnit b
h : ∀ (a b_1 : α), b = a * b_1 → IsUnit a ∨ IsUnit b_1
A B : α
HAB : b * ↑a = A * B
⊢ IsUnit A ∨ IsUnit B

tactic: apply h
state_before: case refine'_2
α : Type u_1
β : Type ?u.91092
γ : Type ?u.91095
δ : Type ?u.91098
inst✝ : Monoid α
a : αˣ
b : α
x✝ : ¬IsUnit b
h : ∀ (a b_1 : α), b = a * b_1 → IsUnit a ∨ IsUnit b_1
A B : α
HAB : b * ↑a = A * B
⊢ IsUnit A ∨ IsUnit (B * ↑a⁻¹)

tactic: rw [← mul_assoc, ← HAB, Units.mul_inv_cancel_right]
state_before: case refine'_2.a
α : Type u_1
β : Type ?u.91092
γ : Type ?u.91095
δ : Type ?u.91098
inst✝ : Monoid α
a : αˣ
b : α
x✝ : ¬IsUnit b
h : ∀ (a b_1 : α), b = a * b_1 → IsUnit a ∨ IsUnit b_1
A B : α
HAB : b * ↑a = A * B
⊢ b = A * (B * ↑a⁻¹)
Theorem: Complex.abs_le_abs_of_mapsTo_ball_self
File: Mathlib/Analysis/Complex/Schwarz.lean

tactic: replace hz : z ∈ ball (0 : ℂ) R
state_before: f : ℂ → ℂ
c z : ℂ
R R₁ R₂ : ℝ
hd : DifferentiableOn ℂ f (ball 0 R)
h_maps : MapsTo f (ball 0 R) (ball 0 R)
h₀ : f 0 = 0
hz : ↑abs z < R
⊢ ↑abs (f z) ≤ ↑abs z

tactic: exact mem_ball_zero_iff.2 hz
state_before: case hz
f : ℂ → ℂ
c z : ℂ
R R₁ R₂ : ℝ
hd : DifferentiableOn ℂ f (ball 0 R)
h_maps : MapsTo f (ball 0 R) (ball 0 R)
h₀ : f 0 = 0
hz : ↑abs z < R
⊢ z ∈ ball 0 R

f : ℂ → ℂ
c z : ℂ
R R₁ R₂ : ℝ
hd : DifferentiableOn ℂ f (ball 0 R)
h_maps : MapsTo f (ball 0 R) (ball 0 R)
h₀ : f 0 = 0
hz : z ∈ ball 0 R
⊢ ↑abs (f z) ≤ ↑abs z

tactic: simpa only [dist_zero_right] using dist_le_dist_of_mapsTo_ball_self hd h_maps h₀ hz
state_before: f : ℂ → ℂ
c z : ℂ
R R₁ R₂ : ℝ
hd : DifferentiableOn ℂ f (ball 0 R)
h_maps : MapsTo f (ball 0 R) (ball 0 R)
h₀ : f 0 = 0
hz : z ∈ ball 0 R
⊢ ↑abs (f z) ≤ ↑abs z
Theorem: Real.sinh_three_mul
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← ofReal_inj]
state_before: x y : ℝ
⊢ sinh (3 * x) = 4 * sinh x ^ 3 + 3 * sinh x

tactic: simp [sinh_three_mul]
state_before: x y : ℝ
⊢ ↑(sinh (3 * x)) = ↑(4 * sinh x ^ 3 + 3 * sinh x)
Theorem: tendsto_order_unbounded
File: Mathlib/Topology/Order/Basic.lean

tactic: simp only [nhds_order_unbounded hu hl, tendsto_iInf, tendsto_principal]
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : Preorder α
t : OrderTopology α
f : β → α
a : α
x : Filter β
hu : ∃ u, a < u
hl : ∃ l, l < a
h : ∀ (l u : α), l < a → a < u → ∀ᶠ (b : β) in x, l < f b ∧ f b < u
⊢ Tendsto f x (𝓝 a)

tactic: exact fun l hl u => h l u hl
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : Preorder α
t : OrderTopology α
f : β → α
a : α
x : Filter β
hu : ∃ u, a < u
hl : ∃ l, l < a
h : ∀ (l u : α), l < a → a < u → ∀ᶠ (b : β) in x, l < f b ∧ f b < u
⊢ ∀ (i : α), i < a → ∀ (i_2 : α), a < i_2 → ∀ᶠ (a : β) in x, f a ∈ Ioo i i_2
Theorem: WithTop.preimage_coe_Ico
File: Mathlib/Data/Set/Intervals/WithBotTop.lean

tactic: simp [← Ici_inter_Iio]
state_before: α : Type u_1
inst✝ : PartialOrder α
a b : α
⊢ some ⁻¹' Ico ↑a ↑b = Ico a b
Theorem: FirstOrder.Language.constantsOnMap_isExpansionOn
File: Mathlib/ModelTheory/LanguageMap.lean

tactic: letI := constantsOn.structure fα
state_before: L : Language
L' : Language
M : Type w
inst✝ : Structure L M
α : Type u'
β : Type v'
f : α → β
fα : α → M
fβ : β → M
h : fβ ∘ f = fα
⊢ LHom.IsExpansionOn (LHom.constantsOnMap f) M

tactic: letI := constantsOn.structure fβ
state_before: L : Language
L' : Language
M : Type w
inst✝ : Structure L M
α : Type u'
β : Type v'
f : α → β
fα : α → M
fβ : β → M
h : fβ ∘ f = fα
this : Structure (constantsOn α) M := constantsOn.structure fα
⊢ LHom.IsExpansionOn (LHom.constantsOnMap f) M

tactic: exact
  ⟨fun {n} => Nat.casesOn n (fun F _x => (congr_fun h F : _)) fun n F => isEmptyElim F, fun R =>
    isEmptyElim R⟩
state_before: L : Language
L' : Language
M : Type w
inst✝ : Structure L M
α : Type u'
β : Type v'
f : α → β
fα : α → M
fβ : β → M
h : fβ ∘ f = fα
this✝ : Structure (constantsOn α) M := constantsOn.structure fα
this : Structure (constantsOn β) M := constantsOn.structure fβ
⊢ LHom.IsExpansionOn (LHom.constantsOnMap f) M
Theorem: map_sdiff'
File: Mathlib/Order/Hom/Lattice.lean

tactic: rw [sdiff_eq, sdiff_eq, map_inf, map_compl']
state_before: F : Type u_3
ι : Type ?u.36141
α : Type u_2
β : Type u_1
γ : Type ?u.36150
δ : Type ?u.36153
inst✝² : BooleanAlgebra α
inst✝¹ : BooleanAlgebra β
inst✝ : BoundedLatticeHomClass F α β
f : F
a b : α
⊢ ↑f (a \ b) = ↑f a \ ↑f b
Theorem: IsCompact.exists_infDist_eq_dist
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: rw [infDist, dist_edist, hy]
state_before: ι : Sort ?u.68670
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x✝ y✝ : α
Φ : α → β
h : IsCompact s
hne : Set.Nonempty s
x y : α
hys : y ∈ s
hy : infEdist x s = edist x y
⊢ infDist x s = dist x y
Theorem: Nat.Linear.ExprCnstr.eq_true_of_isValid
File: src/lean/Init/Data/Nat/Linear.lean

tactic: have := PolyCnstr.eq_true_of_isValid ctx h
state_before: ctx : Context
c : ExprCnstr
h : PolyCnstr.isValid (toNormPoly c) = true
⊢ denote ctx c = True

tactic: simp at this
state_before: ctx : Context
c : ExprCnstr
h : PolyCnstr.isValid (toNormPoly c) = true
this : PolyCnstr.denote ctx (toNormPoly c) = True
⊢ denote ctx c = True

tactic: assumption
state_before: ctx : Context
c : ExprCnstr
h : PolyCnstr.isValid (toNormPoly c) = true
this : denote ctx c = True
⊢ denote ctx c = True
Theorem: EquivFunctor.mapEquiv.injective
File: Mathlib/Control/EquivFunctor.lean

tactic: simpa [EquivFunctor.map] using Equiv.congr_fun H (pure x)
state_before: f : Type u₀ → Type u₁
inst✝¹ : Applicative f
inst✝ : LawfulApplicative f
α β : Type u₀
h : ∀ (γ : Type u₀), Injective pure
e₁ e₂ : α ≃ β
H : mapEquiv f e₁ = mapEquiv f e₂
x : α
⊢ pure (↑e₁ x) = pure (↑e₂ x)
Theorem: MvPolynomial.prod_C_add_X_eq_sum_esymm
File: Mathlib/RingTheory/Polynomial/Vieta.lean

tactic: let s := Finset.univ.val.map fun i : σ => (MvPolynomial.X i : MvPolynomial σ R)
state_before: R : Type u_2
σ : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Fintype σ
⊢ ∏ i : σ, (Polynomial.X + ↑Polynomial.C (X i)) =
    ∑ j in range (Fintype.card σ + 1), ↑Polynomial.C (esymm σ R j) * Polynomial.X ^ (Fintype.card σ - j)

tactic: have : Fintype.card σ = Multiset.card s := by
  rw [Multiset.card_map, ←Finset.card_univ, Finset.card_def]
state_before: R : Type u_2
σ : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Fintype σ
s : Multiset (MvPolynomial σ R) := Multiset.map (fun i => X i) univ.val
⊢ ∏ i : σ, (Polynomial.X + ↑Polynomial.C (X i)) =
    ∑ j in range (Fintype.card σ + 1), ↑Polynomial.C (esymm σ R j) * Polynomial.X ^ (Fintype.card σ - j)

tactic: simp_rw [this, MvPolynomial.esymm_eq_multiset_esymm σ R, Finset.prod_eq_multiset_prod]
state_before: R : Type u_2
σ : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Fintype σ
s : Multiset (MvPolynomial σ R) := Multiset.map (fun i => X i) univ.val
this : Fintype.card σ = ↑Multiset.card s
⊢ ∏ i : σ, (Polynomial.X + ↑Polynomial.C (X i)) =
    ∑ j in range (Fintype.card σ + 1), ↑Polynomial.C (esymm σ R j) * Polynomial.X ^ (Fintype.card σ - j)

tactic: convert Multiset.prod_X_add_C_eq_sum_esymm s
state_before: R : Type u_2
σ : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Fintype σ
s : Multiset (MvPolynomial σ R) := Multiset.map (fun i => X i) univ.val
this : Fintype.card σ = ↑Multiset.card s
⊢ Multiset.prod (Multiset.map (fun x => Polynomial.X + ↑Polynomial.C (X x)) univ.val) =
    ∑ x in range (↑Multiset.card (Multiset.map (fun i => X i) univ.val) + 1),
      ↑Polynomial.C (Multiset.esymm (Multiset.map X univ.val) x) *
        Polynomial.X ^ (↑Multiset.card (Multiset.map (fun i => X i) univ.val) - x)

tactic: simp_rw [Multiset.map_map, Function.comp_apply]
state_before: case h.e'_2.h.e'_3
R : Type u_2
σ : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Fintype σ
s : Multiset (MvPolynomial σ R) := Multiset.map (fun i => X i) univ.val
this : Fintype.card σ = ↑Multiset.card s
⊢ Multiset.map (fun x => Polynomial.X + ↑Polynomial.C (X x)) univ.val =
    Multiset.map (fun r => Polynomial.X + ↑Polynomial.C r) s

tactic: rw [Multiset.card_map, ←Finset.card_univ, Finset.card_def]
state_before: R : Type u_2
σ : Type u_1
inst✝¹ : CommSemiring R
inst✝ : Fintype σ
s : Multiset (MvPolynomial σ R) := Multiset.map (fun i => X i) univ.val
⊢ Fintype.card σ = ↑Multiset.card s
Theorem: Option.mem_some_iff
File: Mathlib/Data/Option/Defs.lean

tactic: simp
state_before: α✝ : Type ?u.1536
β : Type ?u.1539
α : Type u_1
a b : α
⊢ a ∈ some b ↔ b = a
Theorem: derivWithin_inv
File: Mathlib/Analysis/Calculus/Deriv/Inv.lean

tactic: rw [DifferentiableAt.derivWithin (differentiableAt_inv.2 x_ne_zero) hxs]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
x_ne_zero : x ≠ 0
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ derivWithin (fun x => x⁻¹) s x = -(x ^ 2)⁻¹

tactic: exact deriv_inv
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
x_ne_zero : x ≠ 0
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ deriv (fun x => x⁻¹) x = -(x ^ 2)⁻¹
Theorem: Cardinal.lift_natCast
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: induction n <;> simp [*]
state_before: α β : Type u
n : ℕ
⊢ lift ↑n = ↑n
Theorem: Multiset.map_filter
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp [List.map_filter]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.274085
p : α → Prop
inst✝ : DecidablePred p
f : β → α
s : Multiset β
l : List β
⊢ filter p (map f (Quot.mk Setoid.r l)) = map f (filter (p ∘ f) (Quot.mk Setoid.r l))

tactic: rfl
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.274085
p : α → Prop
inst✝ : DecidablePred p
f : β → α
s : Multiset β
l : List β
⊢ List.map f (List.filter ((fun b => decide (p b)) ∘ f) l) ~ List.map f (List.filter (fun b => decide (p (f b))) l)
Theorem: eq_const_of_unique
File: Mathlib/Logic/Unique.lean

tactic: ext x
state_before: α : Sort u_1
β : Sort u_2
inst✝ : Unique α
f : α → β
⊢ f = Function.const α (f default)

tactic: rw [Subsingleton.elim x default]
state_before: case h
α : Sort u_1
β : Sort u_2
inst✝ : Unique α
f : α → β
x : α
⊢ f x = Function.const α (f default) x

tactic: rfl
state_before: case h
α : Sort u_1
β : Sort u_2
inst✝ : Unique α
f : α → β
x : α
⊢ f default = Function.const α (f default) default