tasksource/leandojo huggingface dataset:
Theorem: StieltjesFunction.measure_Icc
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

tactic: rcases le_or_lt a b with (hab | hab)
state_before: f : StieltjesFunction
a b : ℝ
⊢ ↑↑(StieltjesFunction.measure f) (Icc a b) = ofReal (↑f b - leftLim (↑f) a)

tactic: have A : Disjoint {a} (Ioc a b) := by simp
state_before: case inl
f : StieltjesFunction
a b : ℝ
hab : a ≤ b
⊢ ↑↑(StieltjesFunction.measure f) (Icc a b) = ofReal (↑f b - leftLim (↑f) a)

tactic: simp [← Icc_union_Ioc_eq_Icc le_rfl hab, -singleton_union, ← ENNReal.ofReal_add,
  f.mono.leftLim_le, measure_union A measurableSet_Ioc, f.mono hab]
state_before: case inl
f : StieltjesFunction
a b : ℝ
hab : a ≤ b
A : Disjoint {a} (Ioc a b)
⊢ ↑↑(StieltjesFunction.measure f) (Icc a b) = ofReal (↑f b - leftLim (↑f) a)

tactic: simp
state_before: f : StieltjesFunction
a b : ℝ
hab : a ≤ b
⊢ Disjoint {a} (Ioc a b)

tactic: simp only [hab, measure_empty, Icc_eq_empty, not_le]
state_before: case inr
f : StieltjesFunction
a b : ℝ
hab : b < a
⊢ ↑↑(StieltjesFunction.measure f) (Icc a b) = ofReal (↑f b - leftLim (↑f) a)

tactic: symm
state_before: case inr
f : StieltjesFunction
a b : ℝ
hab : b < a
⊢ 0 = ofReal (↑f b - leftLim (↑f) a)

tactic: simp [ENNReal.ofReal_eq_zero, f.mono.le_leftLim hab]
state_before: case inr
f : StieltjesFunction
a b : ℝ
hab : b < a
⊢ ofReal (↑f b - leftLim (↑f) a) = 0
Theorem: tendstoUniformlyOn_iff_tendstoUniformly_comp_coe
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
u : Set (β × β)
x✝ : u ∈ 𝓤 β
⊢ (∀ᶠ (n : ι) in p, ∀ (x : α), x ∈ s → (f x, F n x) ∈ u) ↔
    ∀ᶠ (n : ι) in p, ∀ (x : ↑s), ((f ∘ Subtype.val) x, (fun i x => F i ↑x) n x) ∈ u
Theorem: MeasureTheory.VectorMeasure.le_restrict_univ_iff_le
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: constructor
state_before: α : Type u_1
β : Type ?u.546843
m : MeasurableSpace α
M : Type u_2
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
v w : VectorMeasure α M
⊢ restrict v Set.univ ≤ restrict w Set.univ ↔ v ≤ w

tactic: intro h s hs
state_before: case mp
α : Type u_1
β : Type ?u.546843
m : MeasurableSpace α
M : Type u_2
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
v w : VectorMeasure α M
⊢ restrict v Set.univ ≤ restrict w Set.univ → v ≤ w

tactic: have := h s hs
state_before: case mp
α : Type u_1
β : Type ?u.546843
m : MeasurableSpace α
M : Type u_2
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
v w : VectorMeasure α M
h : restrict v Set.univ ≤ restrict w Set.univ
s : Set α
hs : MeasurableSet s
⊢ ↑v s ≤ ↑w s

tactic: rwa [restrict_apply _ MeasurableSet.univ hs, Set.inter_univ,
  restrict_apply _ MeasurableSet.univ hs, Set.inter_univ] at this
state_before: case mp
α : Type u_1
β : Type ?u.546843
m : MeasurableSpace α
M : Type u_2
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
v w : VectorMeasure α M
h : restrict v Set.univ ≤ restrict w Set.univ
s : Set α
hs : MeasurableSet s
this : ↑(restrict v Set.univ) s ≤ ↑(restrict w Set.univ) s
⊢ ↑v s ≤ ↑w s

tactic: intro h s hs
state_before: case mpr
α : Type u_1
β : Type ?u.546843
m : MeasurableSpace α
M : Type u_2
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
v w : VectorMeasure α M
⊢ v ≤ w → restrict v Set.univ ≤ restrict w Set.univ

tactic: rw [restrict_apply _ MeasurableSet.univ hs, Set.inter_univ,
  restrict_apply _ MeasurableSet.univ hs, Set.inter_univ]
state_before: case mpr
α : Type u_1
β : Type ?u.546843
m : MeasurableSpace α
M : Type u_2
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
v w : VectorMeasure α M
h : v ≤ w
s : Set α
hs : MeasurableSet s
⊢ ↑(restrict v Set.univ) s ≤ ↑(restrict w Set.univ) s

tactic: exact h s hs
state_before: case mpr
α : Type u_1
β : Type ?u.546843
m : MeasurableSpace α
M : Type u_2
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid M
inst✝ : PartialOrder M
v w : VectorMeasure α M
h : v ≤ w
s : Set α
hs : MeasurableSet s
⊢ ↑v s ≤ ↑w s
Theorem: injective_of_lt_imp_ne
File: Mathlib/Order/Monotone/Basic.lean

tactic: intro x y hf
state_before: ι : Type ?u.16131
α : Type u
β : Type v
γ : Type w
δ : Type ?u.16140
π : ι → Type ?u.16145
r : α → α → Prop
inst✝ : LinearOrder α
f : α → β
h : ∀ (x y : α), x < y → f x ≠ f y
⊢ Injective f

tactic: rcases lt_trichotomy x y with (hxy | rfl | hxy)
state_before: ι : Type ?u.16131
α : Type u
β : Type v
γ : Type w
δ : Type ?u.16140
π : ι → Type ?u.16145
r : α → α → Prop
inst✝ : LinearOrder α
f : α → β
h : ∀ (x y : α), x < y → f x ≠ f y
x y : α
hf : f x = f y
⊢ x = y

tactic: exact absurd hf <| h _ _ hxy
state_before: case inl
ι : Type ?u.16131
α : Type u
β : Type v
γ : Type w
δ : Type ?u.16140
π : ι → Type ?u.16145
r : α → α → Prop
inst✝ : LinearOrder α
f : α → β
h : ∀ (x y : α), x < y → f x ≠ f y
x y : α
hf : f x = f y
hxy : x < y
⊢ x = y

tactic: rfl
state_before: case inr.inl
ι : Type ?u.16131
α : Type u
β : Type v
γ : Type w
δ : Type ?u.16140
π : ι → Type ?u.16145
r : α → α → Prop
inst✝ : LinearOrder α
f : α → β
h : ∀ (x y : α), x < y → f x ≠ f y
x : α
hf : f x = f x
⊢ x = x

tactic: exact absurd hf.symm <| h _ _ hxy
state_before: case inr.inr
ι : Type ?u.16131
α : Type u
β : Type v
γ : Type w
δ : Type ?u.16140
π : ι → Type ?u.16145
r : α → α → Prop
inst✝ : LinearOrder α
f : α → β
h : ∀ (x y : α), x < y → f x ≠ f y
x y : α
hf : f x = f y
hxy : y < x
⊢ x = y
Theorem: MeasureTheory.ae_restrict_iUnion_iff
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp
state_before: α : Type u_2
β : Type ?u.559207
γ : Type ?u.559210
δ : Type ?u.559213
ι : Type u_1
R : Type ?u.559219
R' : Type ?u.559222
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝ : Countable ι
s : ι → Set α
p : α → Prop
⊢ (∀ᵐ (x : α) ∂Measure.restrict μ (⋃ (i : ι), s i), p x) ↔ ∀ (i : ι), ∀ᵐ (x : α) ∂Measure.restrict μ (s i), p x
Theorem: Set.compl_iUnion₂
File: Mathlib/Data/Set/Lattice.lean

tactic: simp_rw [compl_iUnion]
state_before: α : Type u_1
β : Type ?u.67630
γ : Type ?u.67633
ι : Sort u_2
ι' : Sort ?u.67639
ι₂ : Sort ?u.67642
κ : ι → Sort u_3
κ₁ : ι → Sort ?u.67652
κ₂ : ι → Sort ?u.67657
κ' : ι' → Sort ?u.67662
s : (i : ι) → κ i → Set α
⊢ (⋃ (i : ι) (j : κ i), s i j)ᶜ = ⋂ (i : ι) (j : κ i), s i jᶜ
Theorem: PowerSeries.exp_mul_exp_neg_eq_one
File: Mathlib/RingTheory/PowerSeries/WellKnown.lean

tactic: convert exp_mul_exp_eq_exp_add (1 : A) (-1) <;> simp
state_before: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
⊢ exp A * ↑evalNegHom (exp A) = 1
Theorem: Real.iInf_mul_of_nonpos
File: Mathlib/Data/Real/Pointwise.lean

tactic: simp only [Real.mul_iInf_of_nonpos ha, mul_comm]
state_before: ι : Sort u_1
α : Type ?u.16734
inst✝ : LinearOrderedField α
r : ℝ
ha : r ≤ 0
f : ι → ℝ
⊢ (⨅ (i : ι), f i) * r = ⨆ (i : ι), f i * r
Theorem: Algebra.adjoin_induction₂
File: Mathlib/RingTheory/Adjoin/Basic.lean

tactic: refine' adjoin_induction hb _ (fun r => _) (Hadd_right a) (Hmul_right a)
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
s t : Set A
p : A → A → Prop
a b : A
ha : a ∈ adjoin R s
hb : b ∈ adjoin R s
Hs : ∀ (x : A), x ∈ s → ∀ (y : A), y ∈ s → p x y
Halg : ∀ (r₁ r₂ : R), p (↑(algebraMap R A) r₁) (↑(algebraMap R A) r₂)
Halg_left : ∀ (r : R) (x : A), x ∈ s → p (↑(algebraMap R A) r) x
Halg_right : ∀ (r : R) (x : A), x ∈ s → p x (↑(algebraMap R A) r)
Hadd_left : ∀ (x₁ x₂ y : A), p x₁ y → p x₂ y → p (x₁ + x₂) y
Hadd_right : ∀ (x y₁ y₂ : A), p x y₁ → p x y₂ → p x (y₁ + y₂)
Hmul_left : ∀ (x₁ x₂ y : A), p x₁ y → p x₂ y → p (x₁ * x₂) y
Hmul_right : ∀ (x y₁ y₂ : A), p x y₁ → p x y₂ → p x (y₁ * y₂)
⊢ p a b

tactic: exact adjoin_induction ha Hs Halg_left
  (fun x y Hx Hy z hz => Hadd_left x y z (Hx z hz) (Hy z hz))
  fun x y Hx Hy z hz => Hmul_left x y z (Hx z hz) (Hy z hz)
state_before: case refine'_1
R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
s t : Set A
p : A → A → Prop
a b : A
ha : a ∈ adjoin R s
hb : b ∈ adjoin R s
Hs : ∀ (x : A), x ∈ s → ∀ (y : A), y ∈ s → p x y
Halg : ∀ (r₁ r₂ : R), p (↑(algebraMap R A) r₁) (↑(algebraMap R A) r₂)
Halg_left : ∀ (r : R) (x : A), x ∈ s → p (↑(algebraMap R A) r) x
Halg_right : ∀ (r : R) (x : A), x ∈ s → p x (↑(algebraMap R A) r)
Hadd_left : ∀ (x₁ x₂ y : A), p x₁ y → p x₂ y → p (x₁ + x₂) y
Hadd_right : ∀ (x y₁ y₂ : A), p x y₁ → p x y₂ → p x (y₁ + y₂)
Hmul_left : ∀ (x₁ x₂ y : A), p x₁ y → p x₂ y → p (x₁ * x₂) y
Hmul_right : ∀ (x y₁ y₂ : A), p x y₁ → p x y₂ → p x (y₁ * y₂)
⊢ ∀ (x : A), x ∈ s → p a x

tactic: exact adjoin_induction ha (Halg_right r) (fun r' => Halg r' r)
  (fun x y => Hadd_left x y ((algebraMap R A) r))
  fun x y => Hmul_left x y ((algebraMap R A) r)
state_before: case refine'_2
R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
s t : Set A
p : A → A → Prop
a b : A
ha : a ∈ adjoin R s
hb : b ∈ adjoin R s
Hs : ∀ (x : A), x ∈ s → ∀ (y : A), y ∈ s → p x y
Halg : ∀ (r₁ r₂ : R), p (↑(algebraMap R A) r₁) (↑(algebraMap R A) r₂)
Halg_left : ∀ (r : R) (x : A), x ∈ s → p (↑(algebraMap R A) r) x
Halg_right : ∀ (r : R) (x : A), x ∈ s → p x (↑(algebraMap R A) r)
Hadd_left : ∀ (x₁ x₂ y : A), p x₁ y → p x₂ y → p (x₁ + x₂) y
Hadd_right : ∀ (x y₁ y₂ : A), p x y₁ → p x y₂ → p x (y₁ + y₂)
Hmul_left : ∀ (x₁ x₂ y : A), p x₁ y → p x₂ y → p (x₁ * x₂) y
Hmul_right : ∀ (x y₁ y₂ : A), p x y₁ → p x y₂ → p x (y₁ * y₂)
r : R
⊢ p a (↑(algebraMap R A) r)
Theorem: eq_of_has_deriv_right_eq
File: Mathlib/Analysis/Calculus/MeanValue.lean

tactic: simp only [← @sub_eq_zero _ _ (f _)] at hi⊢
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.52033
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → E
a b : ℝ
f' g : ℝ → E
derivf : ∀ (x : ℝ), x ∈ Ico a b → HasDerivWithinAt f (f' x) (Ici x) x
derivg : ∀ (x : ℝ), x ∈ Ico a b → HasDerivWithinAt g (f' x) (Ici x) x
fcont : ContinuousOn f (Icc a b)
gcont : ContinuousOn g (Icc a b)
hi : f a = g a
⊢ ∀ (y : ℝ), y ∈ Icc a b → f y = g y

tactic: exact hi ▸ constant_of_has_deriv_right_zero (fcont.sub gcont) fun y hy => by
  simpa only [sub_self] using (derivf y hy).sub (derivg y hy)
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.52033
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → E
a b : ℝ
f' g : ℝ → E
derivf : ∀ (x : ℝ), x ∈ Ico a b → HasDerivWithinAt f (f' x) (Ici x) x
derivg : ∀ (x : ℝ), x ∈ Ico a b → HasDerivWithinAt g (f' x) (Ici x) x
fcont : ContinuousOn f (Icc a b)
gcont : ContinuousOn g (Icc a b)
hi : f a - g a = 0
⊢ ∀ (y : ℝ), y ∈ Icc a b → f y - g y = 0

tactic: simpa only [sub_self] using (derivf y hy).sub (derivg y hy)
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.52033
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → E
a b : ℝ
f' g : ℝ → E
derivf : ∀ (x : ℝ), x ∈ Ico a b → HasDerivWithinAt f (f' x) (Ici x) x
derivg : ∀ (x : ℝ), x ∈ Ico a b → HasDerivWithinAt g (f' x) (Ici x) x
fcont : ContinuousOn f (Icc a b)
gcont : ContinuousOn g (Icc a b)
hi : f a - g a = 0
y : ℝ
hy : y ∈ Ico a b
⊢ HasDerivWithinAt (fun y => f y - g y) 0 (Ici y) y
Theorem: NNReal.iSup_mul_le
File: Mathlib/Data/Real/NNReal.lean

tactic: rw [iSup_mul]
state_before: ι : Sort u_1
f : ι → ℝ≥0
a : ℝ≥0
g : ι → ℝ≥0
h : ℝ≥0
H : ∀ (i : ι), g i * h ≤ a
⊢ iSup g * h ≤ a

tactic: exact ciSup_le' H
state_before: ι : Sort u_1
f : ι → ℝ≥0
a : ℝ≥0
g : ι → ℝ≥0
h : ℝ≥0
H : ∀ (i : ι), g i * h ≤ a
⊢ (⨆ (i : ι), g i * h) ≤ a
Theorem: CategoryTheory.Limits.factorThruImageSubobject_comp_self
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: ext
state_before: C : Type u
inst✝¹ : Category C
X Y Z : C
f : X ⟶ Y
inst✝ : HasImage f
W : C
k : W ⟶ X
h : Factors (imageSubobject f) (k ≫ f)
⊢ factorThru (imageSubobject f) (k ≫ f) h = k ≫ factorThruImageSubobject f

tactic: simp
state_before: case h
C : Type u
inst✝¹ : Category C
X Y Z : C
f : X ⟶ Y
inst✝ : HasImage f
W : C
k : W ⟶ X
h : Factors (imageSubobject f) (k ≫ f)
⊢ factorThru (imageSubobject f) (k ≫ f) h ≫ arrow (imageSubobject f) =
    (k ≫ factorThruImageSubobject f) ≫ arrow (imageSubobject f)
Theorem: abs_sq
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: simpa only [sq] using abs_mul_self x
state_before: β : Type ?u.256337
A : Type ?u.256340
G : Type ?u.256343
M : Type ?u.256346
R : Type u_1
inst✝ : LinearOrderedRing R
x✝ y x : R
⊢ abs (x ^ 2) = x ^ 2
Theorem: continuousAt_const_cpow'
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

tactic: by_cases ha : a = 0
state_before: α : Type ?u.292640
a b : ℂ
h : b ≠ 0
⊢ ContinuousAt (fun x => a ^ x) b

tactic: rw [ha, continuousAt_congr (zero_cpow_eq_nhds h)]
state_before: case pos
α : Type ?u.292640
a b : ℂ
h : b ≠ 0
ha : a = 0
⊢ ContinuousAt (fun x => a ^ x) b

tactic: exact continuousAt_const
state_before: case pos
α : Type ?u.292640
a b : ℂ
h : b ≠ 0
ha : a = 0
⊢ ContinuousAt 0 b

tactic: exact continuousAt_const_cpow ha
state_before: case neg
α : Type ?u.292640
a b : ℂ
h : b ≠ 0
ha : ¬a = 0
⊢ ContinuousAt (fun x => a ^ x) b
Theorem: StieltjesFunction.countable_leftLim_ne
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

tactic: refine Countable.mono ?_ f.mono.countable_not_continuousAt
state_before: f✝ f : StieltjesFunction
⊢ Set.Countable {x | leftLim (↑f) x ≠ ↑f x}

tactic: intro x hx h'x
state_before: f✝ f : StieltjesFunction
⊢ {x | leftLim (↑f) x ≠ ↑f x} ⊆ {x | ¬ContinuousAt (↑f) x}

tactic: apply hx
state_before: f✝ f : StieltjesFunction
x : ℝ
hx : x ∈ {x | leftLim (↑f) x ≠ ↑f x}
h'x : ContinuousAt (↑f) x
⊢ False

tactic: exact tendsto_nhds_unique (f.mono.tendsto_leftLim x) (h'x.tendsto.mono_left nhdsWithin_le_nhds)
state_before: f✝ f : StieltjesFunction
x : ℝ
hx : x ∈ {x | leftLim (↑f) x ≠ ↑f x}
h'x : ContinuousAt (↑f) x
⊢ leftLim (↑f) x = ↑f x
Theorem: PGame.zero_le
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [le_def]
state_before: x : PGame
⊢ 0 ≤ x ↔ ∀ (j : RightMoves x), ∃ i, 0 ≤ moveLeft (moveRight x j) i

tactic: simp
state_before: x : PGame
⊢ ((∀ (i : LeftMoves 0), (∃ i', moveLeft 0 i ≤ moveLeft x i') ∨ ∃ j, moveRight (moveLeft 0 i) j ≤ x) ∧
      ∀ (j : RightMoves x), (∃ i, 0 ≤ moveLeft (moveRight x j) i) ∨ ∃ j', moveRight 0 j' ≤ moveRight x j) ↔
    ∀ (j : RightMoves x), ∃ i, 0 ≤ moveLeft (moveRight x j) i
Theorem: SetLike.lt_iff_le_and_exists
File: Mathlib/Data/SetLike/Basic.lean

tactic: rw [lt_iff_le_not_le, not_le_iff_exists]
state_before: A : Type u_1
B : Type u_2
i : SetLike A B
p q : A
⊢ p < q ↔ p ≤ q ∧ ∃ x, x ∈ q ∧ ¬x ∈ p
Theorem: iUnion_Icc_add_zsmul
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [iUnion_Ioc_add_zsmul hp a, univ_subset_iff] using
  iUnion_mono fun n : ℤ => (Ioc_subset_Icc_self : Ioc (a + n • p) (a + (n + 1) • p) ⊆ Icc _ _)
state_before: α : Type u_1
inst✝¹ : LinearOrderedAddCommGroup α
inst✝ : Archimedean α
p : α
hp : 0 < p
a : α
⊢ (⋃ (n : ℤ), Icc (a + n • p) (a + (n + 1) • p)) = univ
Theorem: ZMod.cast_eq_val
File: Mathlib/Data/ZMod/Basic.lean

tactic: cases n
state_before: n : ℕ
R : Type u_1
inst✝¹ : AddGroupWithOne R
inst✝ : NeZero n
a : ZMod n
⊢ ↑a = ↑(val a)

tactic: rfl
state_before: case succ
R : Type u_1
inst✝¹ : AddGroupWithOne R
n✝ : ℕ
inst✝ : NeZero (Nat.succ n✝)
a : ZMod (Nat.succ n✝)
⊢ ↑a = ↑(val a)

tactic: cases NeZero.ne 0 rfl
state_before: case zero
R : Type u_1
inst✝¹ : AddGroupWithOne R
inst✝ : NeZero Nat.zero
a : ZMod Nat.zero
⊢ ↑a = ↑(val a)
Theorem: EuclideanSpace.norm_eq
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

tactic: simpa only [Real.coe_sqrt, NNReal.coe_sum] using congr_arg ((↑) : ℝ≥0 → ℝ) x.nnnorm_eq
state_before: ι : Type ?u.68894
ι' : Type ?u.68897
𝕜✝ : Type ?u.68900
inst✝¹⁰ : IsROrC 𝕜✝
E : Type ?u.68906
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜✝ E
E' : Type ?u.68926
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜✝ E'
F : Type ?u.68944
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type ?u.68964
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
𝕜 : Type u_1
inst✝¹ : IsROrC 𝕜
n : Type u_2
inst✝ : Fintype n
x : EuclideanSpace 𝕜 n
⊢ ‖x‖ = Real.sqrt (∑ i : n, ‖x i‖ ^ 2)
Theorem: Fintype.card_eq_one_iff
File: Mathlib/Data/Fintype/Card.lean

tactic: rw [← card_unit, card_eq]
state_before: α : Type u_1
β : Type ?u.20214
γ : Type ?u.20217
inst✝¹ : Fintype α
inst✝ : Fintype β
⊢ card α = 1 ↔ ∃ x, ∀ (y : α), y = x

tactic: exact
  ⟨fun ⟨a⟩ => ⟨a.symm (), fun y => a.injective (Subsingleton.elim _ _)⟩,
   fun ⟨x, hx⟩ =>
    ⟨⟨fun _ => (), fun _ => x, fun _ => (hx _).trans (hx _).symm, fun _ =>
        Subsingleton.elim _ _⟩⟩⟩
state_before: α : Type u_1
β : Type ?u.20214
γ : Type ?u.20217
inst✝¹ : Fintype α
inst✝ : Fintype β
⊢ Nonempty (α ≃ Unit) ↔ ∃ x, ∀ (y : α), y = x
Theorem: LipschitzWith.div
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simpa only [div_eq_mul_inv] using hf.mul' hg.inv
state_before: 𝓕 : Type ?u.1207458
𝕜 : Type ?u.1207461
α : Type u_1
ι : Type ?u.1207467
κ : Type ?u.1207470
E : Type u_2
F : Type ?u.1207476
G : Type ?u.1207479
inst✝² : SeminormedCommGroup E
inst✝¹ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : PseudoEMetricSpace α
K Kf Kg : ℝ≥0
f g : α → E
hf : LipschitzWith Kf f
hg : LipschitzWith Kg g
⊢ LipschitzWith (Kf + Kg) fun x => f x / g x
Theorem: Rat.coe_int_div
File: Mathlib/Data/Rat/Lemmas.lean

tactic: rcases h with ⟨c, rfl⟩
state_before: a b : ℤ
h : b ∣ a
⊢ ↑(a / b) = ↑a / ↑b

tactic: rw [mul_comm b, Int.mul_ediv_assoc c (dvd_refl b), Int.cast_mul,
  coe_int_div_self, Int.cast_mul, mul_div_assoc]
state_before: case intro
b c : ℤ
⊢ ↑(b * c / b) = ↑(b * c) / ↑b
Theorem: Finset.image_subset_iff
File: Mathlib/Data/Finset/Image.lean

tactic: norm_cast
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.81640
inst✝ : DecidableEq β
f g : α → β
s : Finset α
t : Finset β
a : α
b c : β
⊢ image f s ⊆ t ↔ f '' ↑s ⊆ ↑t
Theorem: Subgroup.rank_congr
File: Mathlib/GroupTheory/Finiteness.lean

tactic: subst h
state_before: M : Type ?u.114054
N : Type ?u.114057
inst✝⁵ : Monoid M
inst✝⁴ : AddMonoid N
G : Type u_1
H✝ : Type ?u.114069
inst✝³ : Group G
inst✝² : AddGroup H✝
H K : Subgroup G
inst✝¹ : Group.FG { x // x ∈ H }
inst✝ : Group.FG { x // x ∈ K }
h : H = K
⊢ Group.rank { x // x ∈ H } = Group.rank { x // x ∈ K }

tactic: rfl
state_before: M : Type ?u.114054
N : Type ?u.114057
inst✝⁵ : Monoid M
inst✝⁴ : AddMonoid N
G : Type u_1
H✝ : Type ?u.114069
inst✝³ : Group G
inst✝² : AddGroup H✝
H : Subgroup G
inst✝¹ inst✝ : Group.FG { x // x ∈ H }
⊢ Group.rank { x // x ∈ H } = Group.rank { x // x ∈ H }
Theorem: Flow.continuous_toFun
File: Mathlib/Dynamics/Flow.lean

tactic: rw [←curry_uncurry ϕ.toFun]
state_before: τ : Type u_2
inst✝³ : AddCommGroup τ
inst✝² : TopologicalSpace τ
inst✝¹ : TopologicalAddGroup τ
α : Type u_1
inst✝ : TopologicalSpace α
ϕ : Flow τ α
t : τ
⊢ Continuous (toFun ϕ t)

tactic: apply continuous_curry
state_before: τ : Type u_2
inst✝³ : AddCommGroup τ
inst✝² : TopologicalSpace τ
inst✝¹ : TopologicalAddGroup τ
α : Type u_1
inst✝ : TopologicalSpace α
ϕ : Flow τ α
t : τ
⊢ Continuous (curry (uncurry ϕ.toFun) t)

tactic: exact ϕ.cont'
state_before: case h
τ : Type u_2
inst✝³ : AddCommGroup τ
inst✝² : TopologicalSpace τ
inst✝¹ : TopologicalAddGroup τ
α : Type u_1
inst✝ : TopologicalSpace α
ϕ : Flow τ α
t : τ
⊢ Continuous (uncurry ϕ.toFun)
Theorem: Set.image_compl_preimage
File: Mathlib/Data/Set/Image.lean

tactic: rw [compl_eq_univ_diff, image_diff_preimage, image_univ]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.91374
ι : Sort ?u.91377
ι' : Sort ?u.91380
f✝ : ι → α
s✝ t : Set α
f : α → β
s : Set β
⊢ f '' (f ⁻¹' s)ᶜ = range f \ s
Theorem: isClosedMap_smul_left
File: Mathlib/Analysis/NormedSpace/FiniteDimension.lean

tactic: by_cases hc : c = 0
state_before: 𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type v
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type w
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
F' : Type x
inst✝⁵ : AddCommGroup F'
inst✝⁴ : Module 𝕜 F'
inst✝³ : TopologicalSpace F'
inst✝² : TopologicalAddGroup F'
inst✝¹ : ContinuousSMul 𝕜 F'
inst✝ : CompleteSpace 𝕜
c : E
⊢ IsClosedMap fun x => x • c

tactic: simp_rw [hc, smul_zero]
state_before: case pos
𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type v
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type w
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
F' : Type x
inst✝⁵ : AddCommGroup F'
inst✝⁴ : Module 𝕜 F'
inst✝³ : TopologicalSpace F'
inst✝² : TopologicalAddGroup F'
inst✝¹ : ContinuousSMul 𝕜 F'
inst✝ : CompleteSpace 𝕜
c : E
hc : c = 0
⊢ IsClosedMap fun x => x • c

tactic: exact isClosedMap_const
state_before: case pos
𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type v
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type w
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
F' : Type x
inst✝⁵ : AddCommGroup F'
inst✝⁴ : Module 𝕜 F'
inst✝³ : TopologicalSpace F'
inst✝² : TopologicalAddGroup F'
inst✝¹ : ContinuousSMul 𝕜 F'
inst✝ : CompleteSpace 𝕜
c : E
hc : c = 0
⊢ IsClosedMap fun x => 0

tactic: exact (closedEmbedding_smul_left hc).isClosedMap
state_before: case neg
𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
E : Type v
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
F : Type w
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
F' : Type x
inst✝⁵ : AddCommGroup F'
inst✝⁴ : Module 𝕜 F'
inst✝³ : TopologicalSpace F'
inst✝² : TopologicalAddGroup F'
inst✝¹ : ContinuousSMul 𝕜 F'
inst✝ : CompleteSpace 𝕜
c : E
hc : ¬c = 0
⊢ IsClosedMap fun x => x • c
Theorem: BoxIntegral.Integrable.cauchy_map_integralSum_toFilteriUnion
File: Mathlib/Analysis/BoxIntegral/Basic.lean

tactic: refine' ⟨inferInstance, _⟩
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c c₁ c₂ : ℝ≥0
ε ε₁ ε₂ : ℝ
π₁ π₂ : TaggedPrepartition I
h : Integrable I l f vol
π₀ : Prepartition I
⊢ Cauchy (Filter.map (integralSum f vol) (toFilteriUnion l I π₀))

tactic: rw [prod_map_map_eq, ← toFilter_inf_iUnion_eq, ← prod_inf_prod, prod_principal_principal]
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c c₁ c₂ : ℝ≥0
ε ε₁ ε₂ : ℝ
π₁ π₂ : TaggedPrepartition I
h : Integrable I l f vol
π₀ : Prepartition I
⊢ Filter.map (integralSum f vol) (toFilteriUnion l I π₀) ×ˢ Filter.map (integralSum f vol) (toFilteriUnion l I π₀) ≤ 𝓤 F

tactic: exact h.tendsto_integralSum_toFilter_prod_self_inf_iUnion_eq_uniformity.mono_left
  (inf_le_inf_left _ <| principal_mono.2 fun π h => h.1.trans h.2.symm)
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c c₁ c₂ : ℝ≥0
ε ε₁ ε₂ : ℝ
π₁ π₂ : TaggedPrepartition I
h : Integrable I l f vol
π₀ : Prepartition I
⊢ Filter.map (fun p => (integralSum f vol p.fst, integralSum f vol p.snd))
      (toFilter l I ×ˢ toFilter l I ⊓
        𝓟
          ({π | TaggedPrepartition.iUnion π = Prepartition.iUnion π₀} ×ˢ
            {π | TaggedPrepartition.iUnion π = Prepartition.iUnion π₀})) ≤
    𝓤 F
Theorem: CategoryTheory.Abelian.Pseudoelement.zero_of_map_zero
File: Mathlib/CategoryTheory/Abelian/Pseudoelements.lean

tactic: rw [← apply_zero f] at ha
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
P Q : C
f : P ⟶ Q
h : Function.Injective (pseudoApply f)
a : Pseudoelement P
ha : pseudoApply f a = 0
⊢ a = 0

tactic: exact h ha
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
P Q : C
f : P ⟶ Q
h : Function.Injective (pseudoApply f)
a : Pseudoelement P
ha : pseudoApply f a = pseudoApply f 0
⊢ a = 0