tasksource/leandojo huggingface dataset:
Theorem: MonotoneOn.intervalIntegrable
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: rw [intervalIntegrable_iff]
state_before: ι : Type ?u.8489962
𝕜 : Type ?u.8489965
E : Type u_1
F : Type ?u.8489971
A : Type ?u.8489974
inst✝⁴ : NormedAddCommGroup E
μ : MeasureTheory.Measure ℝ
inst✝³ : IsLocallyFiniteMeasure μ
inst✝² : ConditionallyCompleteLinearOrder E
inst✝¹ : OrderTopology E
inst✝ : SecondCountableTopology E
u : ℝ → E
a b : ℝ
hu : MonotoneOn u [[a, b]]
⊢ IntervalIntegrable u μ a b

tactic: exact (hu.integrableOn_isCompact isCompact_uIcc).mono_set Ioc_subset_Icc_self
state_before: ι : Type ?u.8489962
𝕜 : Type ?u.8489965
E : Type u_1
F : Type ?u.8489971
A : Type ?u.8489974
inst✝⁴ : NormedAddCommGroup E
μ : MeasureTheory.Measure ℝ
inst✝³ : IsLocallyFiniteMeasure μ
inst✝² : ConditionallyCompleteLinearOrder E
inst✝¹ : OrderTopology E
inst✝ : SecondCountableTopology E
u : ℝ → E
a b : ℝ
hu : MonotoneOn u [[a, b]]
⊢ IntegrableOn u (Ι a b)
Theorem: Nat.mul_eq_zero
File: Std/Data/Nat/Lemmas.lean

tactic: rw [succ_mul] at h
state_before: n✝ m✝ : Nat
h✝ : n✝ * m✝ = 0
n m : Nat
h : (n + 1) * m = 0
⊢ n + 1 = 0 ∨ m = 0

tactic: exact .inr (Nat.eq_zero_of_add_eq_zero_left h)
state_before: n✝ m✝ : Nat
h✝ : n✝ * m✝ = 0
n m : Nat
h : n * m + m = 0
⊢ n + 1 = 0 ∨ m = 0

tactic: simp [h]
state_before: n m : Nat
h : m = 0
⊢ n * m = 0
Theorem: Set.le_edist_of_le_infsep
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: by_cases hs : s.Nontrivial
state_before: α : Type u_1
β : Type ?u.59969
inst✝ : PseudoMetricSpace α
x✝ y✝ z : α
s t : Set α
d : ℝ
x : α
hx : x ∈ s
y : α
hy : y ∈ s
hxy : x ≠ y
hd : d ≤ infsep s
⊢ d ≤ dist x y

tactic: exact hs.le_infsep_iff.1 hd x hx y hy hxy
state_before: case pos
α : Type u_1
β : Type ?u.59969
inst✝ : PseudoMetricSpace α
x✝ y✝ z : α
s t : Set α
d : ℝ
x : α
hx : x ∈ s
y : α
hy : y ∈ s
hxy : x ≠ y
hd : d ≤ infsep s
hs : Set.Nontrivial s
⊢ d ≤ dist x y

tactic: rw [not_nontrivial_iff] at hs
state_before: case neg
α : Type u_1
β : Type ?u.59969
inst✝ : PseudoMetricSpace α
x✝ y✝ z : α
s t : Set α
d : ℝ
x : α
hx : x ∈ s
y : α
hy : y ∈ s
hxy : x ≠ y
hd : d ≤ infsep s
hs : ¬Set.Nontrivial s
⊢ d ≤ dist x y

tactic: rw [hs.infsep_zero] at hd
state_before: case neg
α : Type u_1
β : Type ?u.59969
inst✝ : PseudoMetricSpace α
x✝ y✝ z : α
s t : Set α
d : ℝ
x : α
hx : x ∈ s
y : α
hy : y ∈ s
hxy : x ≠ y
hd : d ≤ infsep s
hs : Set.Subsingleton s
⊢ d ≤ dist x y

tactic: exact le_trans hd dist_nonneg
state_before: case neg
α : Type u_1
β : Type ?u.59969
inst✝ : PseudoMetricSpace α
x✝ y✝ z : α
s t : Set α
d : ℝ
x : α
hx : x ∈ s
y : α
hy : y ∈ s
hxy : x ≠ y
hd : d ≤ 0
hs : Set.Subsingleton s
⊢ d ≤ dist x y
Theorem: Real.mk_neg
File: Mathlib/Data/Real/Basic.lean

tactic: simp [mk, ← ofCauchy_neg]
state_before: x y : ℝ
f : CauSeq ℚ abs
⊢ mk (-f) = -mk f
Theorem: ENNReal.inv_lt_iff_inv_lt
File: Mathlib/Data/Real/ENNReal.lean

tactic: simpa only [inv_inv] using @ENNReal.inv_lt_inv a b⁻¹
state_before: α : Type ?u.267504
β : Type ?u.267507
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ a⁻¹ < b ↔ b⁻¹ < a
Theorem: rank_matrix'
File: Mathlib/LinearAlgebra/FreeModule/Rank.lean

tactic: rw [rank_matrix, lift_mul, lift_umax.{v, u}]
state_before: R : Type u
M : Type v
N : Type w
inst✝⁹ : Ring R
inst✝⁸ : StrongRankCondition R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : Module.Free R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : Module.Free R N
m n : Type v
inst✝¹ : Finite m
inst✝ : Finite n
⊢ Module.rank R (Matrix m n R) = Cardinal.lift ((#m) * (#n))
Theorem: IsFractional.inf_right
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: rcases mem_inf.mp hb with ⟨hbI, _⟩
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
aI : R
haI : aI ∈ S
hI : ∀ (b : P), b ∈ I → IsInteger R (aI • b)
J : Submodule R P
b : P
hb : b ∈ I ⊓ J
⊢ IsInteger R (aI • b)

tactic: exact hI b hbI
state_before: case intro
R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : Submodule R P
aI : R
haI : aI ∈ S
hI : ∀ (b : P), b ∈ I → IsInteger R (aI • b)
J : Submodule R P
b : P
hb : b ∈ I ⊓ J
hbI : b ∈ I
right✝ : b ∈ J
⊢ IsInteger R (aI • b)
Theorem: NNReal.sqrt_mul_self
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [← sq, sqrt_sq x]
state_before: x✝ y x : ℝ≥0
⊢ ↑sqrt (x * x) = x
Theorem: ENNReal.inv_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: rcases eq_or_ne y 0 with (rfl | hy)
state_before: x : ℝ≥0∞
y : ℝ
⊢ x⁻¹ ^ y = (x ^ y)⁻¹

tactic: replace hy := hy.lt_or_lt
state_before: case inr
x : ℝ≥0∞
y : ℝ
hy : y ≠ 0
⊢ x⁻¹ ^ y = (x ^ y)⁻¹

tactic: rcases eq_or_ne x 0 with (rfl | h0)
state_before: case inr
x : ℝ≥0∞
y : ℝ
hy : y < 0 ∨ 0 < y
⊢ x⁻¹ ^ y = (x ^ y)⁻¹

tactic: rcases eq_or_ne x ⊤ with (rfl | h_top)
state_before: case inr.inr
x : ℝ≥0∞
y : ℝ
hy : y < 0 ∨ 0 < y
h0 : x ≠ 0
⊢ x⁻¹ ^ y = (x ^ y)⁻¹

tactic: apply ENNReal.eq_inv_of_mul_eq_one_left
state_before: case inr.inr.inr
x : ℝ≥0∞
y : ℝ
hy : y < 0 ∨ 0 < y
h0 : x ≠ 0
h_top : x ≠ ⊤
⊢ x⁻¹ ^ y = (x ^ y)⁻¹

tactic: rw [← mul_rpow_of_ne_zero (ENNReal.inv_ne_zero.2 h_top) h0, ENNReal.inv_mul_cancel h0 h_top,
  one_rpow]
state_before: case inr.inr.inr.h
x : ℝ≥0∞
y : ℝ
hy : y < 0 ∨ 0 < y
h0 : x ≠ 0
h_top : x ≠ ⊤
⊢ x⁻¹ ^ y * x ^ y = 1

tactic: simp only [rpow_zero, inv_one]
state_before: case inl
x : ℝ≥0∞
⊢ x⁻¹ ^ 0 = (x ^ 0)⁻¹

tactic: cases hy <;> simp [*]
state_before: case inr.inl
y : ℝ
hy : y < 0 ∨ 0 < y
⊢ 0⁻¹ ^ y = (0 ^ y)⁻¹

tactic: cases hy <;> simp [*]
state_before: case inr.inr.inl
y : ℝ
hy : y < 0 ∨ 0 < y
h0 : ⊤ ≠ 0
⊢ ⊤⁻¹ ^ y = (⊤ ^ y)⁻¹
Theorem: Polynomial.eval_eq_sum_range'
File: Mathlib/Data/Polynomial/Eval.lean

tactic: rw [eval_eq_sum, p.sum_over_range' _ _ hn]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
x✝ : R
p : R[X]
n : ℕ
hn : natDegree p < n
x : R
⊢ eval x p = ∑ i in range n, coeff p i * x ^ i

tactic: simp
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
x✝ : R
p : R[X]
n : ℕ
hn : natDegree p < n
x : R
⊢ ∀ (n : ℕ), 0 * x ^ n = 0
Theorem: MeasureTheory.Lp.norm_toLp
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: erw [norm_def, snorm_congr_ae (Memℒp.coeFn_toLp hf)]
state_before: α : Type u_2
E : Type u_1
F : Type ?u.380800
G : Type ?u.380803
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hf : Memℒp f p
⊢ ‖Memℒp.toLp f hf‖ = ENNReal.toReal (snorm f p μ)
Theorem: Finite.of_equiv
File: Mathlib/Data/Finite/Defs.lean

tactic: cases' h with n e
state_before: α✝ : Sort ?u.366
β : Sort u_2
α : Sort u_1
h : Finite α
f : α ≃ β
⊢ Finite β

tactic: exact Finite.intro (f.symm.trans e)
state_before: case intro
α✝ : Sort ?u.366
β : Sort u_2
α : Sort u_1
f : α ≃ β
n : ℕ
e : α ≃ Fin n
⊢ Finite β
Theorem: Int.clog_of_right_le_one
File: Mathlib/Data/Int/Log.lean

tactic: obtain rfl | hr := hr.eq_or_lt
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hr : r ≤ 1
⊢ clog b r = -↑(Nat.log b ⌊r⁻¹⌋₊)

tactic: rw [clog, if_pos hr, inv_one, Nat.ceil_one, Nat.floor_one, Nat.log_one_right,
  Nat.clog_one_right, Int.ofNat_zero, neg_zero]
state_before: case inl
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
hr : 1 ≤ 1
⊢ clog b 1 = -↑(Nat.log b ⌊1⁻¹⌋₊)

tactic: exact if_neg hr.not_le
state_before: case inr
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r : R
hr✝ : r ≤ 1
hr : r < 1
⊢ clog b r = -↑(Nat.log b ⌊r⁻¹⌋₊)
Theorem: Real.Angle.cos_pos_iff_abs_toReal_lt_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [lt_iff_le_and_ne, lt_iff_le_and_ne, cos_nonneg_iff_abs_toReal_le_pi_div_two, ←
  and_congr_right]
state_before: θ : Angle
⊢ 0 < cos θ ↔ abs (toReal θ) < π / 2

tactic: rintro -
state_before: θ : Angle
⊢ abs (toReal θ) ≤ π / 2 → (abs (toReal θ) ≠ π / 2 ↔ 0 ≠ cos θ)

tactic: rw [Ne.def, Ne.def, not_iff_not, @eq_comm ℝ 0, abs_toReal_eq_pi_div_two_iff, cos_eq_zero_iff]
state_before: θ : Angle
⊢ abs (toReal θ) ≠ π / 2 ↔ 0 ≠ cos θ
Theorem: mul_self_sub_one
File: Mathlib/Algebra/Ring/Commute.lean

tactic: rw [← (Commute.one_right a).mul_self_sub_mul_self_eq, mul_one]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : NonAssocRing R
a : R
⊢ a * a - 1 = (a + 1) * (a - 1)
Theorem: PFunctor.M.isubtree_cons
File: Mathlib/Data/PFunctor/Univariate/M.lean

tactic: simp only [isubtree, ichildren_mk, PFunctor.Obj.iget, dif_pos, isubtree, M.casesOn_mk']
state_before: F : PFunctor
X : Type ?u.27518
f✝ : X → Obj F X
inst✝¹ : DecidableEq F.A
inst✝ : Inhabited (M F)
ps : Path F
a : F.A
f : B F a → M F
i : B F a
⊢ isubtree ({ fst := a, snd := i } :: ps) (M.mk { fst := a, snd := f }) = isubtree ps (f i)

tactic: rfl
state_before: F : PFunctor
X : Type ?u.27518
f✝ : X → Obj F X
inst✝¹ : DecidableEq F.A
inst✝ : Inhabited (M F)
ps : Path F
a : F.A
f : B F a → M F
i : B F a
⊢ isubtree ps (f (cast (_ : B F a = B F a) i)) = isubtree ps (f i)
Theorem: Set.sInter_eq_biInter
File: Mathlib/Data/Set/Lattice.lean

tactic: rw [← sInter_image, image_id']
state_before: α : Type u_1
β : Type ?u.167139
γ : Type ?u.167142
ι : Sort ?u.167145
ι' : Sort ?u.167148
ι₂ : Sort ?u.167151
κ : ι → Sort ?u.167156
κ₁ : ι → Sort ?u.167161
κ₂ : ι → Sort ?u.167166
κ' : ι' → Sort ?u.167171
s : Set (Set α)
⊢ ⋂₀ s = ⋂ (i : Set α) (_ : i ∈ s), i
Theorem: Filter.prod_pure_pure
File: Mathlib/Order/Filter/Prod.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.44519
δ : Type ?u.44522
ι : Sort ?u.44525
s : Set α
t : Set β
f : Filter α
g : Filter β
a : α
b : β
⊢ pure a ×ˢ pure b = pure (a, b)
Theorem: CategoryTheory.dcongr_arg
File: Mathlib/CategoryTheory/EqToHom.lean

tactic: subst h
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
ι : Type u_1
F G : ι → C
α : (i : ι) → F i ⟶ G i
i j : ι
h : i = j
⊢ α i = eqToHom (_ : F i = F j) ≫ α j ≫ eqToHom (_ : G j = G i)

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
ι : Type u_1
F G : ι → C
α : (i : ι) → F i ⟶ G i
i : ι
⊢ α i = eqToHom (_ : F i = F i) ≫ α i ≫ eqToHom (_ : G i = G i)
Theorem: Real.toNNReal_of_nonneg
File: Mathlib/Data/Real/NNReal.lean

tactic: simp_rw [Real.toNNReal, max_eq_left hr]
state_before: r : ℝ
hr : 0 ≤ r
⊢ Real.toNNReal r = { val := r, property := hr }
Theorem: Pi.OmegaCompletePartialOrder.flip₂_continuous'
File: Mathlib/Order/OmegaCompletePartialOrder.lean

tactic: intro c
state_before: α : Type u_3
β : α → Type u_2
γ : Type u_1
inst✝¹ : (x : α) → OmegaCompletePartialOrder (β x)
inst✝ : OmegaCompletePartialOrder γ
f : γ → (x : α) → β x
hf : ∀ (x : α), Continuous' fun g => f g x
⊢ Continuous { toFun := f, monotone' := (_ : ∀ (x y : γ), x ≤ y → ∀ (a : α), (fun g => f g a) x ≤ (fun g => f g a) y) }

tactic: ext a
state_before: α : Type u_3
β : α → Type u_2
γ : Type u_1
inst✝¹ : (x : α) → OmegaCompletePartialOrder (β x)
inst✝ : OmegaCompletePartialOrder γ
f : γ → (x : α) → β x
hf : ∀ (x : α), Continuous' fun g => f g x
c : Chain γ
⊢ ↑{ toFun := f, monotone' := (_ : ∀ (x y : γ), x ≤ y → ∀ (a : α), (fun g => f g a) x ≤ (fun g => f g a) y) } (ωSup c) =
    ωSup
      (map c { toFun := f, monotone' := (_ : ∀ (x y : γ), x ≤ y → ∀ (a : α), (fun g => f g a) x ≤ (fun g => f g a) y) })

tactic: apply (hf a).to_bundled _ c
state_before: case h
α : Type u_3
β : α → Type u_2
γ : Type u_1
inst✝¹ : (x : α) → OmegaCompletePartialOrder (β x)
inst✝ : OmegaCompletePartialOrder γ
f : γ → (x : α) → β x
hf : ∀ (x : α), Continuous' fun g => f g x
c : Chain γ
a : α
⊢ ↑{ toFun := f, monotone' := (_ : ∀ (x y : γ), x ≤ y → ∀ (a : α), (fun g => f g a) x ≤ (fun g => f g a) y) } (ωSup c)
      a =
    ωSup
      (map c { toFun := f, monotone' := (_ : ∀ (x y : γ), x ≤ y → ∀ (a : α), (fun g => f g a) x ≤ (fun g => f g a) y) })
      a
Theorem: ContinuousAffineMap.to_affine_map_contLinear
File: Mathlib/Analysis/NormedSpace/ContinuousAffineMap.lean

tactic: ext
state_before: 𝕜 : Type ?u.62366
R : Type u_1
V : Type u_2
W : Type u_3
W₂ : Type ?u.62378
P : Type ?u.62381
Q : Type ?u.62384
Q₂ : Type ?u.62387
inst✝¹⁶ : NormedAddCommGroup V
inst✝¹⁵ : MetricSpace P
inst✝¹⁴ : NormedAddTorsor V P
inst✝¹³ : NormedAddCommGroup W
inst✝¹² : MetricSpace Q
inst✝¹¹ : NormedAddTorsor W Q
inst✝¹⁰ : NormedAddCommGroup W₂
inst✝⁹ : MetricSpace Q₂
inst✝⁸ : NormedAddTorsor W₂ Q₂
inst✝⁷ : NormedField R
inst✝⁶ : NormedSpace R V
inst✝⁵ : NormedSpace R W
inst✝⁴ : NormedSpace R W₂
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 V
inst✝¹ : NormedSpace 𝕜 W
inst✝ : NormedSpace 𝕜 W₂
f : V →L[R] W
⊢ contLinear (ContinuousLinearMap.toContinuousAffineMap f) = f

tactic: rfl
state_before: case h
𝕜 : Type ?u.62366
R : Type u_1
V : Type u_2
W : Type u_3
W₂ : Type ?u.62378
P : Type ?u.62381
Q : Type ?u.62384
Q₂ : Type ?u.62387
inst✝¹⁶ : NormedAddCommGroup V
inst✝¹⁵ : MetricSpace P
inst✝¹⁴ : NormedAddTorsor V P
inst✝¹³ : NormedAddCommGroup W
inst✝¹² : MetricSpace Q
inst✝¹¹ : NormedAddTorsor W Q
inst✝¹⁰ : NormedAddCommGroup W₂
inst✝⁹ : MetricSpace Q₂
inst✝⁸ : NormedAddTorsor W₂ Q₂
inst✝⁷ : NormedField R
inst✝⁶ : NormedSpace R V
inst✝⁵ : NormedSpace R W
inst✝⁴ : NormedSpace R W₂
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 V
inst✝¹ : NormedSpace 𝕜 W
inst✝ : NormedSpace 𝕜 W₂
f : V →L[R] W
x✝ : V
⊢ ↑(contLinear (ContinuousLinearMap.toContinuousAffineMap f)) x✝ = ↑f x✝
Theorem: Asymptotics.isBigO_cofinite_iff
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp [h _ hx, hx]
state_before: α : Type u_3
β : Type ?u.683301
E : Type ?u.683304
F : Type ?u.683307
G : Type ?u.683310
E' : Type ?u.683313
F' : Type ?u.683316
G' : Type ?u.683319
E'' : Type u_2
F'' : Type u_1
G'' : Type ?u.683328
R : Type ?u.683331
R' : Type ?u.683334
𝕜 : Type ?u.683337
𝕜' : Type ?u.683340
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
h : ∀ (x : α), g'' x = 0 → f'' x = 0
h' : f'' =O[cofinite] g''
C : ℝ
_C₀ : C > 0
hC : ∀ ⦃x : α⦄, g'' x ≠ 0 → ‖f'' x‖ ≤ C * ‖g'' x‖
x : α
hx : g'' x = 0
⊢ ‖f'' x‖ ≤ C * ‖g'' x‖
Theorem: AlgebraicTopology.DoldKan.MorphComponents.preComp_φ
File: Mathlib/AlgebraicTopology/DoldKan/Decomposition.lean

tactic: unfold φ preComp
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X X' : SimplicialObject C
n : ℕ
Z Z' : C
f : MorphComponents X n Z
g : X' ⟶ X
h : Z ⟶ Z'
⊢ φ (preComp f g) = g.app [n + 1].op ≫ φ f

tactic: simp only [PInfty_f, comp_add]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X X' : SimplicialObject C
n : ℕ
Z Z' : C
f : MorphComponents X n Z
g : X' ⟶ X
h : Z ⟶ Z'
⊢ HomologicalComplex.Hom.f PInfty (n + 1) ≫ { a := g.app [n + 1].op ≫ f.a, b := fun i => g.app [n].op ≫ b f i }.a +
      ∑ i : Fin (n + 1),
        HomologicalComplex.Hom.f (P ↑i) (n + 1) ≫
          SimplicialObject.δ X' (Fin.succ (↑Fin.rev i)) ≫
            b { a := g.app [n + 1].op ≫ f.a, b := fun i => g.app [n].op ≫ b f i } (↑Fin.rev i) =
    g.app [n + 1].op ≫
      (HomologicalComplex.Hom.f PInfty (n + 1) ≫ f.a +
        ∑ i : Fin (n + 1),
          HomologicalComplex.Hom.f (P ↑i) (n + 1) ≫ SimplicialObject.δ X (Fin.succ (↑Fin.rev i)) ≫ b f (↑Fin.rev i))

tactic: congr 1
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X X' : SimplicialObject C
n : ℕ
Z Z' : C
f : MorphComponents X n Z
g : X' ⟶ X
h : Z ⟶ Z'
⊢ HomologicalComplex.Hom.f (P (n + 1)) (n + 1) ≫ g.app [n + 1].op ≫ f.a +
      ∑ x : Fin (n + 1),
        HomologicalComplex.Hom.f (P ↑x) (n + 1) ≫
          SimplicialObject.δ X' (Fin.succ (↑Fin.rev x)) ≫ g.app [n].op ≫ b f (↑Fin.rev x) =
    g.app [n + 1].op ≫ HomologicalComplex.Hom.f (P (n + 1)) (n + 1) ≫ f.a +
      g.app [n + 1].op ≫
        ∑ x : Fin (n + 1),
          HomologicalComplex.Hom.f (P ↑x) (n + 1) ≫ SimplicialObject.δ X (Fin.succ (↑Fin.rev x)) ≫ b f (↑Fin.rev x)

tactic: simp only [P_f_naturality_assoc]
state_before: case e_a
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X X' : SimplicialObject C
n : ℕ
Z Z' : C
f : MorphComponents X n Z
g : X' ⟶ X
h : Z ⟶ Z'
⊢ HomologicalComplex.Hom.f (P (n + 1)) (n + 1) ≫ g.app [n + 1].op ≫ f.a =
    g.app [n + 1].op ≫ HomologicalComplex.Hom.f (P (n + 1)) (n + 1) ≫ f.a

tactic: simp only [comp_sum, P_f_naturality_assoc, SimplicialObject.δ_naturality_assoc]
state_before: case e_a
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X X' : SimplicialObject C
n : ℕ
Z Z' : C
f : MorphComponents X n Z
g : X' ⟶ X
h : Z ⟶ Z'
⊢ ∑ x : Fin (n + 1),
      HomologicalComplex.Hom.f (P ↑x) (n + 1) ≫
        SimplicialObject.δ X' (Fin.succ (↑Fin.rev x)) ≫ g.app [n].op ≫ b f (↑Fin.rev x) =
    g.app [n + 1].op ≫
      ∑ x : Fin (n + 1),
        HomologicalComplex.Hom.f (P ↑x) (n + 1) ≫ SimplicialObject.δ X (Fin.succ (↑Fin.rev x)) ≫ b f (↑Fin.rev x)
Theorem: AlgEquiv.algebraMap_eq_apply
File: Mathlib/Algebra/Algebra/Equiv.lean

tactic: simpa using e.symm.toAlgHom.algebraMap_eq_apply h
state_before: R : Type u
A₁ : Type v
A₂ : Type w
A₃ : Type u₁
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A₁
inst✝⁴ : Semiring A₂
inst✝³ : Semiring A₃
inst✝² : Algebra R A₁
inst✝¹ : Algebra R A₂
inst✝ : Algebra R A₃
e✝ e : A₁ ≃ₐ[R] A₂
y : R
x : A₁
h : ↑(algebraMap R A₂) y = ↑e x
⊢ ↑(algebraMap R A₁) y = x
Theorem: BoundedContinuousFunction.norm_lt_iff_of_nonempty_compact
File: Mathlib/Topology/ContinuousFunction/Bounded.lean

tactic: simp_rw [norm_def, ← dist_zero_right]
state_before: F : Type ?u.1009057
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : SeminormedAddCommGroup β
f✝ g : α →ᵇ β
x : α
C : ℝ
inst✝¹ : Nonempty α
inst✝ : CompactSpace α
f : α →ᵇ β
M : ℝ
⊢ ‖f‖ < M ↔ ∀ (x : α), ‖↑f x‖ < M

tactic: exact dist_lt_iff_of_nonempty_compact
state_before: F : Type ?u.1009057
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : SeminormedAddCommGroup β
f✝ g : α →ᵇ β
x : α
C : ℝ
inst✝¹ : Nonempty α
inst✝ : CompactSpace α
f : α →ᵇ β
M : ℝ
⊢ dist f 0 < M ↔ ∀ (x : α), dist (↑f x) 0 < M
Theorem: Set.Finite.toFinset_setOf
File: Mathlib/Data/Set/Finite.lean

tactic: ext
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs : Set.Finite s
ht : Set.Finite t
inst✝¹ : Fintype α
p : α → Prop
inst✝ : DecidablePred p
h : Set.Finite {x | p x}
⊢ Finite.toFinset h = Finset.filter p Finset.univ

tactic: simp
state_before: case a
α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs : Set.Finite s
ht : Set.Finite t
inst✝¹ : Fintype α
p : α → Prop
inst✝ : DecidablePred p
h : Set.Finite {x | p x}
a✝ : α
⊢ a✝ ∈ Finite.toFinset h ↔ a✝ ∈ Finset.filter p Finset.univ
Theorem: Metric.thickening_union
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: simp_rw [thickening, infEdist_union, inf_eq_min, min_lt_iff, setOf_or]
state_before: ι : Sort ?u.113978
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s✝ t✝ : Set α
x : α
δ : ℝ
s t : Set α
⊢ thickening δ (s ∪ t) = thickening δ s ∪ thickening δ t
Theorem: ContinuousMultilinearMap.mkPiField_zero
File: Mathlib/Analysis/NormedSpace/Multilinear.lean

tactic: ext
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
⊢ ContinuousMultilinearMap.mkPiField 𝕜 ι 0 = 0

tactic: rw [mkPiField_apply, smul_zero, ContinuousMultilinearMap.zero_apply]
state_before: case H
𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
x✝ : ι → 𝕜
⊢ ↑(ContinuousMultilinearMap.mkPiField 𝕜 ι 0) x✝ = ↑0 x✝
Theorem: VitaliFamily.eventually_filterAt_mem_sets
File: Mathlib/MeasureTheory/Covering/VitaliFamily.lean

tactic: simp (config := { contextual := true }) only [eventually_filterAt_iff, exists_prop, and_true_iff,
  gt_iff_lt, imp_true_iff]
state_before: α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v : VitaliFamily μ
x : α
⊢ ∀ᶠ (a : Set α) in filterAt v x, a ∈ setsAt v x

tactic: exact ⟨1, zero_lt_one⟩
state_before: α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v : VitaliFamily μ
x : α
⊢ ∃ ε, 0 < ε
Theorem: ContinuousOn.surjOn_uIcc
File: Mathlib/Topology/Algebra/Order/IntermediateValue.lean

tactic: cases' le_total (f a) (f b) with hab hab <;> simp [hf.surjOn_Icc, *]
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹⁰ : ConditionallyCompleteLinearOrder α
inst✝⁹ : TopologicalSpace α
inst✝⁸ : OrderTopology α
inst✝⁷ : ConditionallyCompleteLinearOrder β
inst✝⁶ : TopologicalSpace β
inst✝⁵ : OrderTopology β
inst✝⁴ : Nonempty γ
inst✝³ : DenselyOrdered α
a✝ b✝ : α
δ : Type u_1
inst✝² : LinearOrder δ
inst✝¹ : TopologicalSpace δ
inst✝ : OrderClosedTopology δ
s : Set α
hs : OrdConnected s
f : α → δ
hf : ContinuousOn f s
a b : α
ha : a ∈ s
hb : b ∈ s
⊢ SurjOn f s (uIcc (f a) (f b))
Theorem: Finset.mulEtransformLeft_one
File: Mathlib/Combinatorics/Additive/Etransform.lean

tactic: simp [mulEtransformLeft]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Group α
e : α
x : Finset α × Finset α
⊢ mulEtransformLeft 1 x = x
Theorem: OrthonormalBasis.orthogonalProjection_eq_sum
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

tactic: simpa only [b.repr_apply_apply, inner_orthogonalProjection_eq_of_mem_left] using
  (b.sum_repr (orthogonalProjection U x)).symm
state_before: ι : Type u_3
ι' : Type ?u.859551
𝕜 : Type u_1
inst✝¹⁰ : IsROrC 𝕜
E : Type u_2
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type ?u.859580
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type ?u.859598
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type ?u.859618
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : Fintype ι
U : Submodule 𝕜 E
inst✝ : CompleteSpace { x // x ∈ U }
b : OrthonormalBasis ι 𝕜 { x // x ∈ U }
x : E
⊢ ↑(orthogonalProjection U) x = ∑ i : ι, inner (↑(↑b i)) x • ↑b i
Theorem: inner_eq_one_iff_of_norm_one
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: convert inner_eq_norm_mul_iff (𝕜 := 𝕜) (E := E) using 2 <;> simp [hx, hy]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.3233193
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
hx : ‖x‖ = 1
hy : ‖y‖ = 1
⊢ inner x y = 1 ↔ x = y
Theorem: le_inv_of_neg
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [← inv_le_inv_of_neg (inv_lt_zero.2 hb) ha, inv_inv]
state_before: ι : Type ?u.150874
α : Type u_1
β : Type ?u.150880
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
ha : a < 0
hb : b < 0
⊢ a ≤ b⁻¹ ↔ b ≤ a⁻¹