1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.Limits.pullbackRightPullbackFstIso_inv_snd_fst
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: rw [← pullback.condition]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
f' : W ⟶ X
inst✝² : HasPullback f g
inst✝¹ : HasPullback f' pullback.fst
inst✝ : HasPullback (f' ≫ f) g
⊢ (pullbackRightPullbackFstIso f g f').inv ≫ pullback.snd ≫ pullback.fst = pullback.fst ≫ f'
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
f' : W ⟶ X
inst✝² : HasPullback f g
inst✝¹ : HasPullback f' pullback.fst
inst✝ : HasPullback (f' ≫ f) g
⊢ (pullbackRightPullbackFstIso f g f').inv ≫ pullback.fst ≫ f' = pullback.fst ≫ f'

tactic: exact pullbackRightPullbackFstIso_inv_fst_assoc _ _ _ _
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
f' : W ⟶ X
inst✝² : HasPullback f g
inst✝¹ : HasPullback f' pullback.fst
inst✝ : HasPullback (f' ≫ f) g
⊢ (pullbackRightPullbackFstIso f g f').inv ≫ pullback.fst ≫ f' = pullback.fst ≫ f'
state_after: no goals
Theorem: CategoryTheory.InitiallySmall.exists_small_weakly_initial_set
File: Mathlib/CategoryTheory/Limits/FinallySmall.lean

tactic: refine ⟨Set.range (fromInitialModel J).obj, inferInstance, fun i => ?_⟩
state_before: J : Type u
inst✝¹ : Category.{v, u} J
inst✝ : InitiallySmall J
⊢ ∃ s, ∃ (_ : Small.{w, u} ↑s), ∀ (i : J), ∃ j ∈ s, Nonempty (j ⟶ i)
state_after: J : Type u
inst✝¹ : Category.{v, u} J
inst✝ : InitiallySmall J
i : J
⊢ ∃ j ∈ Set.range (fromInitialModel J).obj, Nonempty (j ⟶ i)

tactic: obtain ⟨f⟩ : Nonempty (CostructuredArrow (fromInitialModel J) i) := IsConnected.is_nonempty
state_before: J : Type u
inst✝¹ : Category.{v, u} J
inst✝ : InitiallySmall J
i : J
⊢ ∃ j ∈ Set.range (fromInitialModel J).obj, Nonempty (j ⟶ i)
state_after: case intro
J : Type u
inst✝¹ : Category.{v, u} J
inst✝ : InitiallySmall J
i : J
f : CostructuredArrow (fromInitialModel J) i
⊢ ∃ j ∈ Set.range (fromInitialModel J).obj, Nonempty (j ⟶ i)

tactic: exact ⟨(fromInitialModel J).obj f.left, Set.mem_range_self _, ⟨f.hom⟩⟩
state_before: case intro
J : Type u
inst✝¹ : Category.{v, u} J
inst✝ : InitiallySmall J
i : J
f : CostructuredArrow (fromInitialModel J) i
⊢ ∃ j ∈ Set.range (fromInitialModel J).obj, Nonempty (j ⟶ i)
state_after: no goals
Theorem: Equiv.Perm.sameCycle_inv
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: simp [SameCycle]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
p : α → Prop
x y z : α
⊢ (∃ b, (f⁻¹ ^ (Equiv.symm (Equiv.neg ℤ)) b) x = y) ↔ f.SameCycle x y
state_after: no goals
Theorem: MeasureTheory.Submartingale.tendsto_snorm_one_limitProcess
File: Mathlib/Probability/Martingale/Convergence.lean

tactic: obtain ⟨R, hR⟩ := hunif.2.2
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
a b : ℝ
f : ℕ → Ω → ℝ
ω : Ω
R : ℝ≥0
inst✝ : IsFiniteMeasure μ
g : Ω → ℝ
hf : Submartingale f ℱ μ
hunif : UniformIntegrable f 1 μ
⊢ Tendsto (fun n => snorm (f n - limitProcess f ℱ μ) 1 μ) atTop (𝓝 0)
state_after: case intro
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
a b : ℝ
f : ℕ → Ω → ℝ
ω : Ω
R✝ : ℝ≥0
inst✝ : IsFiniteMeasure μ
g : Ω → ℝ
hf : Submartingale f ℱ μ
hunif : UniformIntegrable f 1 μ
R : ℝ≥0
hR : ∀ (i : ℕ), snorm (f i) 1 μ ≤ ↑R
⊢ Tendsto (fun n => snorm (f n - limitProcess f ℱ μ) 1 μ) atTop (𝓝 0)

tactic: have hmeas : ∀ n, AEStronglyMeasurable (f n) μ := fun n =>
  ((hf.stronglyMeasurable n).mono (ℱ.le _)).aestronglyMeasurable
state_before: case intro
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
a b : ℝ
f : ℕ → Ω → ℝ
ω : Ω
R✝ : ℝ≥0
inst✝ : IsFiniteMeasure μ
g : Ω → ℝ
hf : Submartingale f ℱ μ
hunif : UniformIntegrable f 1 μ
R : ℝ≥0
hR : ∀ (i : ℕ), snorm (f i) 1 μ ≤ ↑R
⊢ Tendsto (fun n => snorm (f n - limitProcess f ℱ μ) 1 μ) atTop (𝓝 0)
state_after: case intro
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
a b : ℝ
f : ℕ → Ω → ℝ
ω : Ω
R✝ : ℝ≥0
inst✝ : IsFiniteMeasure μ
g : Ω → ℝ
hf : Submartingale f ℱ μ
hunif : UniformIntegrable f 1 μ
R : ℝ≥0
hR : ∀ (i : ℕ), snorm (f i) 1 μ ≤ ↑R
hmeas : ∀ (n : ℕ), AEStronglyMeasurable (f n) μ
⊢ Tendsto (fun n => snorm (f n - limitProcess f ℱ μ) 1 μ) atTop (𝓝 0)

tactic: exact tendsto_Lp_of_tendstoInMeasure le_rfl ENNReal.one_ne_top hmeas
  (memℒp_limitProcess_of_snorm_bdd hmeas hR) hunif.2.1
  (tendstoInMeasure_of_tendsto_ae hmeas <| hf.ae_tendsto_limitProcess hR)
state_before: case intro
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
a b : ℝ
f : ℕ → Ω → ℝ
ω : Ω
R✝ : ℝ≥0
inst✝ : IsFiniteMeasure μ
g : Ω → ℝ
hf : Submartingale f ℱ μ
hunif : UniformIntegrable f 1 μ
R : ℝ≥0
hR : ∀ (i : ℕ), snorm (f i) 1 μ ≤ ↑R
hmeas : ∀ (n : ℕ), AEStronglyMeasurable (f n) μ
⊢ Tendsto (fun n => snorm (f n - limitProcess f ℱ μ) 1 μ) atTop (𝓝 0)
state_after: no goals
Theorem: nhdsWithin_pi_neBot
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp [neBot_iff, nhdsWithin_pi_eq_bot]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝ : (i : ι) → TopologicalSpace (π i)
I : Set ι
s : (i : ι) → Set (π i)
x : (i : ι) → π i
⊢ (𝓝[I.pi s] x).NeBot ↔ ∀ i ∈ I, (𝓝[s i] x i).NeBot
state_after: no goals
Theorem: sup_sdiff_symmDiff
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff_eq_sup_sdiff_inf]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
⊢ (a ⊔ b) \ (a ⊓ b) = a ∆ b
state_after: no goals
Theorem: CategoryTheory.GradedObject.mapBifunctorLeftUnitorCofan_inj
File: Mathlib/CategoryTheory/GradedObject/Unitor.lean

tactic: simp [mapBifunctorLeftUnitorCofan]
state_before: C : Type u_1
D : Type u_2
I : Type u_3
J : Type u_4
inst✝⁵ : Category.{u_6, u_1} C
inst✝⁴ : Category.{u_5, u_2} D
inst✝³ : Zero I
inst✝² : DecidableEq I
inst✝¹ : HasInitial C
F : C ⥤ D ⥤ D
X : C
e : F.obj X ≅ 𝟭 D
inst✝ : (Y : D) → PreservesColimit (Functor.empty C) (F.flip.obj Y)
p : I × J → J
hp : ∀ (j : J), p (0, j) = j
Y Y' : GradedObject J D
φ : Y ⟶ Y'
j : J
⊢ Cofan.inj (mapBifunctorLeftUnitorCofan F X e p hp Y j) ⟨(0, j), ⋯⟩ =
    (F.map (singleObjApplyIso 0 X).hom).app (Y j) ≫ e.hom.app (Y j)
state_after: no goals
Theorem: PosSMulReflectLT.lift
File: Mathlib/Algebra/Order/Module/Defs.lean

tactic: simp only [← lt_iff_lt_of_le_iff_le' hf hf, smul] at *
state_before: α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
hf : ∀ {b₁ b₂ : β}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂
smul : ∀ (a : α) (b : β), f (a • b) = a • f b
zero : f 0 = 0
inst✝ : PosSMulReflectLT α γ
a : α
ha : 0 ≤ a
b₁ b₂ : β
h : a • b₁ < a • b₂
⊢ b₁ < b₂
state_after: α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
hf : ∀ {b₁ b₂ : β}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂
zero : f 0 = 0
inst✝ : PosSMulReflectLT α γ
a : α
ha : 0 ≤ a
b₁ b₂ : β
smul : α → β → True
h : a • f b₁ < a • f b₂
⊢ f b₁ < f b₂

tactic: exact lt_of_smul_lt_smul_left h ha
state_before: α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
hf : ∀ {b₁ b₂ : β}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂
zero : f 0 = 0
inst✝ : PosSMulReflectLT α γ
a : α
ha : 0 ≤ a
b₁ b₂ : β
smul : α → β → True
h : a • f b₁ < a • f b₂
⊢ f b₁ < f b₂
state_after: no goals
Theorem: Valued.loc_const
File: Mathlib/Topology/Algebra/Valuation.lean

tactic: rw [mem_nhds]
state_before: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
x : R
h : v x ≠ 0
⊢ {y | v y = v x} ∈ 𝓝 x
state_after: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
x : R
h : v x ≠ 0
⊢ ∃ γ, {y | v (y - x) < ↑γ} ⊆ {y | v y = v x}

tactic: use Units.mk0 _ h
state_before: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
x : R
h : v x ≠ 0
⊢ ∃ γ, {y | v (y - x) < ↑γ} ⊆ {y | v y = v x}
state_after: case h
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
x : R
h : v x ≠ 0
⊢ {y | v (y - x) < ↑(Units.mk0 (v x) h)} ⊆ {y | v y = v x}

tactic: rw [Units.val_mk0]
state_before: case h
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
x : R
h : v x ≠ 0
⊢ {y | v (y - x) < ↑(Units.mk0 (v x) h)} ⊆ {y | v y = v x}
state_after: case h
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
x : R
h : v x ≠ 0
⊢ {y | v (y - x) < v x} ⊆ {y | v y = v x}

tactic: intro y y_in
state_before: case h
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
x : R
h : v x ≠ 0
⊢ {y | v (y - x) < v x} ⊆ {y | v y = v x}
state_after: case h
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
x : R
h : v x ≠ 0
y : R
y_in : y ∈ {y | v (y - x) < v x}
⊢ y ∈ {y | v y = v x}

tactic: exact Valuation.map_eq_of_sub_lt _ y_in
state_before: case h
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
x : R
h : v x ≠ 0
y : R
y_in : y ∈ {y | v (y - x) < v x}
⊢ y ∈ {y | v y = v x}
state_after: no goals
Theorem: sup_assoc
File: Mathlib/Order/Lattice.lean

tactic: simp only [sup_le_iff]
state_before: α : Type u
β : Type v
inst✝ : SemilatticeSup α
a✝ b✝ c✝ d a b c x : α
⊢ a ⊔ b ⊔ c ≤ x ↔ a ⊔ (b ⊔ c) ≤ x
state_after: α : Type u
β : Type v
inst✝ : SemilatticeSup α
a✝ b✝ c✝ d a b c x : α
⊢ (a ≤ x ∧ b ≤ x) ∧ c ≤ x ↔ a ≤ x ∧ b ≤ x ∧ c ≤ x

tactic: rw [and_assoc]
state_before: α : Type u
β : Type v
inst✝ : SemilatticeSup α
a✝ b✝ c✝ d a b c x : α
⊢ (a ≤ x ∧ b ≤ x) ∧ c ≤ x ↔ a ≤ x ∧ b ≤ x ∧ c ≤ x
state_after: no goals
Theorem: HasFDerivWithinAt.cpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: convert
  (@Complex.hasFDerivAt_cpow ((fun x => (f x, g x)) x) h0).comp_hasFDerivWithinAt x (hf.prod hg)
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f g : E → ℂ
f' g' : E →L[ℂ] ℂ
x : E
s : Set E
c : ℂ
hf : HasFDerivWithinAt f f' s x
hg : HasFDerivWithinAt g g' s x
h0 : f x ∈ slitPlane
⊢ HasFDerivWithinAt (fun x => f x ^ g x) ((g x * f x ^ (g x - 1)) • f' + (f x ^ g x * Complex.log (f x)) • g') s x
state_after: no goals
Theorem: ENNReal.add_iInf
File: Mathlib/Data/ENNReal/Real.lean

tactic: rw [add_comm, iInf_add]
state_before: ι : Sort u_1
f g : ι → ℝ≥0∞
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
⊢ a + iInf f = ⨅ b, a + f b
state_after: ι : Sort u_1
f g : ι → ℝ≥0∞
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
⊢ ⨅ i, f i + a = ⨅ b, a + f b

tactic: simp [add_comm]
state_before: ι : Sort u_1
f g : ι → ℝ≥0∞
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
⊢ ⨅ i, f i + a = ⨅ b, a + f b
state_after: no goals
Theorem: Nat.geom_sum_Ico_le
File: Mathlib/Algebra/GeomSum.lean

tactic: cases' n with n
state_before: α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ ∑ i ∈ Ico 1 n, a / b ^ i ≤ a / (b - 1)
state_after: case zero
α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a : ℕ
⊢ ∑ i ∈ Ico 1 0, a / b ^ i ≤ a / (b - 1)

case succ
α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ ∑ i ∈ Ico 1 (n + 1), a / b ^ i ≤ a / (b - 1)

tactic: rw [← add_le_add_iff_left a]
state_before: case succ
α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ ∑ i ∈ Ico 1 (n + 1), a / b ^ i ≤ a / (b - 1)
state_after: case succ
α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ a + ∑ i ∈ Ico 1 (n + 1), a / b ^ i ≤ a + a / (b - 1)

tactic: calc
  (a + ∑ i ∈ Ico 1 n.succ, a / b ^ i) = a / b ^ 0 + ∑ i ∈ Ico 1 n.succ, a / b ^ i := by
    rw [pow_zero, Nat.div_one]
  _ = ∑ i ∈ range n.succ, a / b ^ i := by
    rw [range_eq_Ico, ← Nat.Ico_insert_succ_left (Nat.succ_pos _), sum_insert]
    exact fun h => zero_lt_one.not_le (mem_Ico.1 h).1
  _ ≤ a * b / (b - 1) := Nat.geom_sum_le hb a _
  _ = (a * 1 + a * (b - 1)) / (b - 1) := by
    rw [← mul_add, add_tsub_cancel_of_le (one_le_two.trans hb)]
  _ = a + a / (b - 1) := by rw [mul_one, Nat.add_mul_div_right _ _ (tsub_pos_of_lt hb), add_comm]
state_before: case succ
α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ a + ∑ i ∈ Ico 1 (n + 1), a / b ^ i ≤ a + a / (b - 1)
state_after: no goals

tactic: rw [Ico_eq_empty_of_le (zero_le_one' ℕ), sum_empty]
state_before: case zero
α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a : ℕ
⊢ ∑ i ∈ Ico 1 0, a / b ^ i ≤ a / (b - 1)
state_after: case zero
α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a : ℕ
⊢ 0 ≤ a / (b - 1)

tactic: exact Nat.zero_le _
state_before: case zero
α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a : ℕ
⊢ 0 ≤ a / (b - 1)
state_after: no goals

tactic: rw [pow_zero, Nat.div_one]
state_before: α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ a + ∑ i ∈ Ico 1 n.succ, a / b ^ i = a / b ^ 0 + ∑ i ∈ Ico 1 n.succ, a / b ^ i
state_after: no goals

tactic: rw [range_eq_Ico, ← Nat.Ico_insert_succ_left (Nat.succ_pos _), sum_insert]
state_before: α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ a / b ^ 0 + ∑ i ∈ Ico 1 n.succ, a / b ^ i = ∑ i ∈ range n.succ, a / b ^ i
state_after: α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ 0 ∉ Ico (succ 0) n.succ

tactic: exact fun h => zero_lt_one.not_le (mem_Ico.1 h).1
state_before: α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ 0 ∉ Ico (succ 0) n.succ
state_after: no goals

tactic: rw [← mul_add, add_tsub_cancel_of_le (one_le_two.trans hb)]
state_before: α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ a * b / (b - 1) = (a * 1 + a * (b - 1)) / (b - 1)
state_after: no goals

tactic: rw [mul_one, Nat.add_mul_div_right _ _ (tsub_pos_of_lt hb), add_comm]
state_before: α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ (a * 1 + a * (b - 1)) / (b - 1) = a + a / (b - 1)
state_after: no goals
Theorem: Num.add_one
File: Mathlib/Data/Num/Lemmas.lean

tactic: cases p <;> rfl
state_before: α : Type u_1
p : PosNum
⊢ pos p + 1 = (pos p).succ
state_after: no goals
Theorem: MeasureTheory.OuterMeasure.exists_measurable_superset_of_trim_eq_zero
File: Mathlib/MeasureTheory/OuterMeasure/Induced.lean

tactic: rcases exists_measurable_superset_eq_trim m s with ⟨t, hst, ht, hm⟩
state_before: α : Type u_1
inst✝ : MeasurableSpace α
m✝ m : OuterMeasure α
s : Set α
h : m.trim s = 0
⊢ ∃ t, s ⊆ t ∧ MeasurableSet t ∧ m t = 0
state_after: case intro.intro.intro
α : Type u_1
inst✝ : MeasurableSpace α
m✝ m : OuterMeasure α
s : Set α
h : m.trim s = 0
t : Set α
hst : s ⊆ t
ht : MeasurableSet t
hm : m t = m.trim s
⊢ ∃ t, s ⊆ t ∧ MeasurableSet t ∧ m t = 0

tactic: exact ⟨t, hst, ht, h ▸ hm⟩
state_before: case intro.intro.intro
α : Type u_1
inst✝ : MeasurableSpace α
m✝ m : OuterMeasure α
s : Set α
h : m.trim s = 0
t : Set α
hst : s ⊆ t
ht : MeasurableSet t
hm : m t = m.trim s
⊢ ∃ t, s ⊆ t ∧ MeasurableSet t ∧ m t = 0
state_after: no goals
Theorem: List.pairwise_of_forall_mem_list
File: Mathlib/Data/List/Pairwise.lean

tactic: rw [pairwise_iff_forall_sublist]
state_before: α : Type u_1
β : Type u_2
R S T : α → α → Prop
a : α
l✝ l : List α
r : α → α → Prop
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → r a b
⊢ Pairwise r l
state_after: α : Type u_1
β : Type u_2
R S T : α → α → Prop
a : α
l✝ l : List α
r : α → α → Prop
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → r a b
⊢ ∀ {a b : α}, [a, b] <+ l → r a b

tactic: intro a b hab
state_before: α : Type u_1
β : Type u_2
R S T : α → α → Prop
a : α
l✝ l : List α
r : α → α → Prop
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → r a b
⊢ ∀ {a b : α}, [a, b] <+ l → r a b
state_after: α : Type u_1
β : Type u_2
R S T : α → α → Prop
a✝ : α
l✝ l : List α
r : α → α → Prop
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → r a b
a b : α
hab : [a, b] <+ l
⊢ r a b

tactic: apply h <;> (apply hab.subset; simp)
state_before: α : Type u_1
β : Type u_2
R S T : α → α → Prop
a✝ : α
l✝ l : List α
r : α → α → Prop
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → r a b
a b : α
hab : [a, b] <+ l
⊢ r a b
state_after: no goals

tactic: apply hab.subset
state_before: case a
α : Type u_1
β : Type u_2
R S T : α → α → Prop
a✝ : α
l✝ l : List α
r : α → α → Prop
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → r a b
a b : α
hab : [a, b] <+ l
⊢ b ∈ l
state_after: case a.a
α : Type u_1
β : Type u_2
R S T : α → α → Prop
a✝ : α
l✝ l : List α
r : α → α → Prop
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → r a b
a b : α
hab : [a, b] <+ l
⊢ b ∈ [a, b]

tactic: simp
state_before: case a.a
α : Type u_1
β : Type u_2
R S T : α → α → Prop
a✝ : α
l✝ l : List α
r : α → α → Prop
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → r a b
a b : α
hab : [a, b] <+ l
⊢ b ∈ [a, b]
state_after: no goals
Theorem: Computation.map_comp
File: Mathlib/Data/Seq/Computation.lean

tactic: apply Subtype.eq
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, s n = some a → s (n + 1) = some a
⊢ map (g ∘ f) ⟨s, al⟩ = map g (map f ⟨s, al⟩)
state_after: case a
α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, s n = some a → s (n + 1) = some a
⊢ ↑(map (g ∘ f) ⟨s, al⟩) = ↑(map g (map f ⟨s, al⟩))

tactic: dsimp [map]
state_before: case a
α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, s n = some a → s (n + 1) = some a
⊢ ↑(map (g ∘ f) ⟨s, al⟩) = ↑(map g (map f ⟨s, al⟩))
state_after: case a
α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, s n = some a → s (n + 1) = some a
⊢ Stream'.map (fun o => Option.rec none (fun val => some (g (f val))) o) s =
    Stream'.map
      ((fun o => Option.rec none (fun val => some (g val)) o) ∘ fun o => Option.rec none (fun val => some (f val)) o) s

tactic: apply congr_arg fun f : _ → Option γ => Stream'.map f s
state_before: case a
α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, s n = some a → s (n + 1) = some a
⊢ Stream'.map (fun o => Option.rec none (fun val => some (g (f val))) o) s =
    Stream'.map
      ((fun o => Option.rec none (fun val => some (g val)) o) ∘ fun o => Option.rec none (fun val => some (f val)) o) s
state_after: case a
α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, s n = some a → s (n + 1) = some a
⊢ (fun o => Option.rec none (fun val => some (g (f val))) o) =
    (fun o => Option.rec none (fun val => some (g val)) o) ∘ fun o => Option.rec none (fun val => some (f val)) o

tactic: ext ⟨⟩ <;> rfl
state_before: case a
α : Type u
β : Type v
γ : Type w
f : α → β
g : β → γ
s : Stream' (Option α)
al : ∀ ⦃n : ℕ⦄ ⦃a : α⦄, s n = some a → s (n + 1) = some a
⊢ (fun o => Option.rec none (fun val => some (g (f val))) o) =
    (fun o => Option.rec none (fun val => some (g val)) o) ∘ fun o => Option.rec none (fun val => some (f val)) o
state_after: no goals
Theorem: norm_sup_le_add
File: Mathlib/Analysis/Normed/Order/Lattice.lean

tactic: have h : ‖x ⊔ y - 0 ⊔ 0‖ ≤ ‖x - 0‖ + ‖y - 0‖ := norm_sup_sub_sup_le_add_norm x y 0 0
state_before: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
x y : α
⊢ ‖x ⊔ y‖ ≤ ‖x‖ + ‖y‖
state_after: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
x y : α
h : ‖x ⊔ y - 0 ⊔ 0‖ ≤ ‖x - 0‖ + ‖y - 0‖
⊢ ‖x ⊔ y‖ ≤ ‖x‖ + ‖y‖

tactic: simpa only [sup_idem, sub_zero] using h
state_before: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
x y : α
h : ‖x ⊔ y - 0 ⊔ 0‖ ≤ ‖x - 0‖ + ‖y - 0‖
⊢ ‖x ⊔ y‖ ≤ ‖x‖ + ‖y‖
state_after: no goals
Theorem: Matrix.compl_apply_diag
File: Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean

tactic: simp [compl]
state_before: V : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : DecidableEq α
inst✝² : DecidableEq V
A : Matrix V V α
inst✝¹ : Zero α
inst✝ : One α
i : V
⊢ A.compl i i = 0
state_after: no goals
Theorem: CategoryTheory.ShortComplex.LeftHomologyData.leftHomologyIso_hom_naturality
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

tactic: dsimp [homologyIso, ShortComplex.leftHomologyIso, homologyMap, homologyMap', leftHomologyIso]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ✝ : S₁ ⟶ S₂
h₁✝ : S₁.HomologyData
h₂✝ : S₂.HomologyData
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
φ : S₁ ⟶ S₂
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
⊢ h₁.homologyIso.hom ≫ leftHomologyMap' φ h₁ h₂ = homologyMap φ ≫ h₂.homologyIso.hom
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ✝ : S₁ ⟶ S₂
h₁✝ : S₁.HomologyData
h₂✝ : S₂.HomologyData
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
φ : S₁ ⟶ S₂
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
⊢ (leftHomologyMap' (𝟙 S₁) S₁.homologyData.left S₁.leftHomologyData ≫ leftHomologyMap' (𝟙 S₁) S₁.leftHomologyData h₁) ≫
      leftHomologyMap' φ h₁ h₂ =
    leftHomologyMap' φ S₁.homologyData.left S₂.homologyData.left ≫
      leftHomologyMap' (𝟙 S₂) S₂.homologyData.left S₂.leftHomologyData ≫ leftHomologyMap' (𝟙 S₂) S₂.leftHomologyData h₂

tactic: simp only [← leftHomologyMap'_comp, id_comp, comp_id]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ✝ : S₁ ⟶ S₂
h₁✝ : S₁.HomologyData
h₂✝ : S₂.HomologyData
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
φ : S₁ ⟶ S₂
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
⊢ (leftHomologyMap' (𝟙 S₁) S₁.homologyData.left S₁.leftHomologyData ≫ leftHomologyMap' (𝟙 S₁) S₁.leftHomologyData h₁) ≫
      leftHomologyMap' φ h₁ h₂ =
    leftHomologyMap' φ S₁.homologyData.left S₂.homologyData.left ≫
      leftHomologyMap' (𝟙 S₂) S₂.homologyData.left S₂.leftHomologyData ≫ leftHomologyMap' (𝟙 S₂) S₂.leftHomologyData h₂
state_after: no goals
Theorem: IsCoprime.pow_left
File: Mathlib/RingTheory/Coprime/Lemmas.lean

tactic: rw [← Finset.card_range m, ← Finset.prod_const]
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℕ
H : IsCoprime x y
⊢ IsCoprime (x ^ m) y
state_after: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℕ
H : IsCoprime x y
⊢ IsCoprime (∏ _x ∈ range m, x) y

tactic: exact IsCoprime.prod_left fun _ _ ↦ H
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℕ
H : IsCoprime x y
⊢ IsCoprime (∏ _x ∈ range m, x) y
state_after: no goals
Theorem: MeasureTheory.FiniteMeasure.eq_of_forall_toMeasure_apply_eq
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: apply Subtype.ext
state_before: Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ ν : FiniteMeasure Ω
h : ∀ (s : Set Ω), MeasurableSet s → ↑μ s = ↑ν s
⊢ μ = ν
state_after: case a
Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ ν : FiniteMeasure Ω
h : ∀ (s : Set Ω), MeasurableSet s → ↑μ s = ↑ν s
⊢ ↑μ = ↑ν

tactic: ext1 s s_mble
state_before: case a
Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ ν : FiniteMeasure Ω
h : ∀ (s : Set Ω), MeasurableSet s → ↑μ s = ↑ν s
⊢ ↑μ = ↑ν
state_after: case a.h
Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ ν : FiniteMeasure Ω
h : ∀ (s : Set Ω), MeasurableSet s → ↑μ s = ↑ν s
s : Set Ω
s_mble : MeasurableSet s
⊢ ↑μ s = ↑ν s

tactic: exact h s s_mble
state_before: case a.h
Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ ν : FiniteMeasure Ω
h : ∀ (s : Set Ω), MeasurableSet s → ↑μ s = ↑ν s
s : Set Ω
s_mble : MeasurableSet s
⊢ ↑μ s = ↑ν s
state_after: no goals
Theorem: Fin.foldr_succ_last
File: .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean

tactic: simp [foldr_succ, Fin.last]
state_before: case zero
α : Sort u_1
f : Fin (0 + 1) → α → α
x : α
⊢ foldr (0 + 1) f x = foldr 0 (fun x => f x.castSucc) (f (last 0) x)
state_after: no goals

tactic: simp [succ_castSucc]
state_before: case succ
α : Sort u_1
n : Nat
ih : ∀ (f : Fin (n + 1) → α → α) (x : α), foldr (n + 1) f x = foldr n (fun x => f x.castSucc) (f (last n) x)
f : Fin (n + 1 + 1) → α → α
x : α
⊢ f 0 (foldr n (fun x => f x.castSucc.succ) (f (last n).succ x)) =
    f (castSucc 0) (foldr n (fun i => f i.succ.castSucc) (f (last (n + 1)) x))
state_after: no goals