1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: VitaliFamily.ae_tendsto_limRatioMeas
File: Mathlib/MeasureTheory/Covering/Differentiation.lean

tactic: filter_upwards [v.ae_tendsto_limRatio hρ, AEMeasurable.ae_eq_mk (v.aemeasurable_limRatio hρ)]
state_before: α : Type u_1
inst✝⁵ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
E : Type u_2
inst✝⁴ : NormedAddCommGroup E
inst✝³ : SecondCountableTopology α
inst✝² : BorelSpace α
inst✝¹ : IsLocallyFiniteMeasure μ
ρ : Measure α
inst✝ : IsLocallyFiniteMeasure ρ
hρ : ρ ≪ μ
⊢ ∀ᵐ (x : α) ∂μ, Tendsto (fun a => ρ a / μ a) (v.filterAt x) (𝓝 (v.limRatioMeas hρ x))
state_after: case h
α : Type u_1
inst✝⁵ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
E : Type u_2
inst✝⁴ : NormedAddCommGroup E
inst✝³ : SecondCountableTopology α
inst✝² : BorelSpace α
inst✝¹ : IsLocallyFiniteMeasure μ
ρ : Measure α
inst✝ : IsLocallyFiniteMeasure ρ
hρ : ρ ≪ μ
⊢ ∀ (a : α),
    Tendsto (fun a => ρ a / μ a) (v.filterAt a) (𝓝 (v.limRatio ρ a)) →
      v.limRatio ρ a = AEMeasurable.mk (v.limRatio ρ) ⋯ a →
        Tendsto (fun a => ρ a / μ a) (v.filterAt a) (𝓝 (v.limRatioMeas hρ a))

tactic: intro x hx h'x
state_before: case h
α : Type u_1
inst✝⁵ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
E : Type u_2
inst✝⁴ : NormedAddCommGroup E
inst✝³ : SecondCountableTopology α
inst✝² : BorelSpace α
inst✝¹ : IsLocallyFiniteMeasure μ
ρ : Measure α
inst✝ : IsLocallyFiniteMeasure ρ
hρ : ρ ≪ μ
⊢ ∀ (a : α),
    Tendsto (fun a => ρ a / μ a) (v.filterAt a) (𝓝 (v.limRatio ρ a)) →
      v.limRatio ρ a = AEMeasurable.mk (v.limRatio ρ) ⋯ a →
        Tendsto (fun a => ρ a / μ a) (v.filterAt a) (𝓝 (v.limRatioMeas hρ a))
state_after: case h
α : Type u_1
inst✝⁵ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
E : Type u_2
inst✝⁴ : NormedAddCommGroup E
inst✝³ : SecondCountableTopology α
inst✝² : BorelSpace α
inst✝¹ : IsLocallyFiniteMeasure μ
ρ : Measure α
inst✝ : IsLocallyFiniteMeasure ρ
hρ : ρ ≪ μ
x : α
hx : Tendsto (fun a => ρ a / μ a) (v.filterAt x) (𝓝 (v.limRatio ρ x))
h'x : v.limRatio ρ x = AEMeasurable.mk (v.limRatio ρ) ⋯ x
⊢ Tendsto (fun a => ρ a / μ a) (v.filterAt x) (𝓝 (v.limRatioMeas hρ x))

tactic: rwa [h'x] at hx
state_before: case h
α : Type u_1
inst✝⁵ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
E : Type u_2
inst✝⁴ : NormedAddCommGroup E
inst✝³ : SecondCountableTopology α
inst✝² : BorelSpace α
inst✝¹ : IsLocallyFiniteMeasure μ
ρ : Measure α
inst✝ : IsLocallyFiniteMeasure ρ
hρ : ρ ≪ μ
x : α
hx : Tendsto (fun a => ρ a / μ a) (v.filterAt x) (𝓝 (v.limRatio ρ x))
h'x : v.limRatio ρ x = AEMeasurable.mk (v.limRatio ρ) ⋯ x
⊢ Tendsto (fun a => ρ a / μ a) (v.filterAt x) (𝓝 (v.limRatioMeas hρ x))
state_after: no goals
Theorem: mabs_sup_div_sup_le_mabs
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: apply le_of_mul_le_of_one_le_left _ (one_le_mabs _)
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b c : α
⊢ mabs ((a ⊔ c) / (b ⊔ c)) ≤ mabs (a / b)
state_after: α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b c : α
⊢ mabs ((a ⊔ c) / (b ⊔ c)) * mabs ?m.30498 ≤ mabs (a / b)

tactic: rw [mabs_div_sup_mul_mabs_div_inf]
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b c : α
⊢ mabs ((a ⊔ c) / (b ⊔ c)) * mabs ?m.30498 ≤ mabs (a / b)
state_after: no goals
Theorem: CategoryTheory.Limits.prodComparison_inv_natural
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: rw [IsIso.eq_comp_inv, Category.assoc, IsIso.inv_comp_eq, prodComparison_natural]
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
X Y : C
D : Type u₂
inst✝⁶ : Category.{w, u₂} D
F : C ⥤ D
A A' B B' : C
inst✝⁵ : HasBinaryProduct A B
inst✝⁴ : HasBinaryProduct A' B'
inst✝³ : HasBinaryProduct (F.obj A) (F.obj B)
inst✝² : HasBinaryProduct (F.obj A') (F.obj B')
f : A ⟶ A'
g : B ⟶ B'
inst✝¹ : IsIso (prodComparison F A B)
inst✝ : IsIso (prodComparison F A' B')
⊢ inv (prodComparison F A B) ≫ F.map (prod.map f g) = prod.map (F.map f) (F.map g) ≫ inv (prodComparison F A' B')
state_after: no goals
Theorem: CategoryTheory.Limits.limit.isoLimitCone_hom_π
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: dsimp [limit.isoLimitCone, IsLimit.conePointUniqueUpToIso]
state_before: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u
inst✝¹ : Category.{v, u} C
F✝ F : J ⥤ C
inst✝ : HasLimit F
t : LimitCone F
j : J
⊢ (isoLimitCone t).hom ≫ t.cone.π.app j = π F j
state_after: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u
inst✝¹ : Category.{v, u} C
F✝ F : J ⥤ C
inst✝ : HasLimit F
t : LimitCone F
j : J
⊢ t.isLimit.lift (cone F) ≫ t.cone.π.app j = π F j

tactic: aesop_cat
state_before: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u
inst✝¹ : Category.{v, u} C
F✝ F : J ⥤ C
inst✝ : HasLimit F
t : LimitCone F
j : J
⊢ t.isLimit.lift (cone F) ≫ t.cone.π.app j = π F j
state_after: no goals
Theorem: Function.update_sup
File: Mathlib/Order/Lattice.lean

tactic: obtain rfl | hji := eq_or_ne j i <;> simp [update_noteq, *]
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → SemilatticeSup (π i)
f : (i : ι) → π i
i : ι
a b : π i
j : ι
⊢ update f i (a ⊔ b) j = (update f i a ⊔ update f i b) j
state_after: no goals
Theorem: nhds_top_basis
File: Mathlib/Topology/Order/Basic.lean

tactic: have : ∃ x : α, x < ⊤ := (exists_ne ⊤).imp fun x hx => hx.lt_top
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderTop α
inst✝¹ : OrderTopology α
inst✝ : Nontrivial α
⊢ (𝓝 ⊤).HasBasis (fun a => a < ⊤) fun a => Ioi a
state_after: α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderTop α
inst✝¹ : OrderTopology α
inst✝ : Nontrivial α
this : ∃ x, x < ⊤
⊢ (𝓝 ⊤).HasBasis (fun a => a < ⊤) fun a => Ioi a

tactic: simpa only [Iic_top, nhdsWithin_univ, Ioc_top] using nhdsWithin_Iic_basis' this
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderTop α
inst✝¹ : OrderTopology α
inst✝ : Nontrivial α
this : ∃ x, x < ⊤
⊢ (𝓝 ⊤).HasBasis (fun a => a < ⊤) fun a => Ioi a
state_after: no goals
Theorem: LinearEquiv.coord_self
File: Mathlib/LinearAlgebra/Span.lean

tactic: rw [← toSpanNonzeroSingleton_one R M x h, LinearEquiv.symm_apply_apply]
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
x : M
h : x ≠ 0
⊢ (coord R M x h) ⟨x, ⋯⟩ = 1
state_after: no goals
Theorem: MeasureTheory.setLIntegral_const_lt_top
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [lintegral_const]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝ : IsFiniteMeasure μ
s : Set α
c : ℝ≥0∞
hc : c ≠ ⊤
⊢ ∫⁻ (x : α) in s, c ∂μ < ⊤
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝ : IsFiniteMeasure μ
s : Set α
c : ℝ≥0∞
hc : c ≠ ⊤
⊢ c * (μ.restrict s) univ < ⊤

tactic: exact ENNReal.mul_lt_top hc (measure_ne_top (μ.restrict s) univ)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝ : IsFiniteMeasure μ
s : Set α
c : ℝ≥0∞
hc : c ≠ ⊤
⊢ c * (μ.restrict s) univ < ⊤
state_after: no goals
Theorem: List.subperm_nil
File: Mathlib/Data/List/Perm.lean

tactic: rintro rfl
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
⊢ l = [] → l <+~ []
state_after: α : Type u_1
β : Type u_2
l₁ l₂ : List α
a : α
⊢ [] <+~ []

tactic: rfl
state_before: α : Type u_1
β : Type u_2
l₁ l₂ : List α
a : α
⊢ [] <+~ []
state_after: no goals
Theorem: Matrix.mulVec_cramer
File: Mathlib/LinearAlgebra/Matrix/Adjugate.lean

tactic: rw [cramer_eq_adjugate_mulVec, mulVec_mulVec, mul_adjugate, smul_mulVec_assoc, one_mulVec]
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
b : n → α
⊢ A *ᵥ A.cramer b = A.det • b
state_after: no goals
Theorem: MeasureTheory.hasPDF_iff_of_aemeasurable
File: Mathlib/Probability/Density.lean

tactic: rw [hasPDF_iff]
state_before: Ω : Type u_1
E : Type u_2
inst✝ : MeasurableSpace E
x✝ : MeasurableSpace Ω
X : Ω → E
ℙ : Measure Ω
μ : Measure E
hX : AEMeasurable X ℙ
⊢ HasPDF X ℙ μ ↔ (map X ℙ).HaveLebesgueDecomposition μ ∧ map X ℙ ≪ μ
state_after: Ω : Type u_1
E : Type u_2
inst✝ : MeasurableSpace E
x✝ : MeasurableSpace Ω
X : Ω → E
ℙ : Measure Ω
μ : Measure E
hX : AEMeasurable X ℙ
⊢ AEMeasurable X ℙ ∧ (map X ℙ).HaveLebesgueDecomposition μ ∧ map X ℙ ≪ μ ↔
    (map X ℙ).HaveLebesgueDecomposition μ ∧ map X ℙ ≪ μ

tactic: simp only [hX, true_and]
state_before: Ω : Type u_1
E : Type u_2
inst✝ : MeasurableSpace E
x✝ : MeasurableSpace Ω
X : Ω → E
ℙ : Measure Ω
μ : Measure E
hX : AEMeasurable X ℙ
⊢ AEMeasurable X ℙ ∧ (map X ℙ).HaveLebesgueDecomposition μ ∧ map X ℙ ≪ μ ↔
    (map X ℙ).HaveLebesgueDecomposition μ ∧ map X ℙ ≪ μ
state_after: no goals
Theorem: Complex.cosh_add_aux
File: Mathlib/Data/Complex/Exponential.lean

tactic: ring
state_before: x y a b c d : ℂ
⊢ (a + b) * (c + d) + (a - b) * (c - d) = 2 * (a * c + b * d)
state_after: no goals
Theorem: Matroid.Restriction.strictRestriction_of_ground_ne
File: Mathlib/Data/Matroid/Restrict.lean

tactic: rw [← h.eq_restrict]
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
N : Matroid α
h : N ≤r M
hne : N.E ≠ M.E
⊢ N <r M
state_after: α : Type u_1
M : Matroid α
R I J X Y : Set α
N : Matroid α
h : N ≤r M
hne : N.E ≠ M.E
⊢ M ↾ N.E <r M

tactic: exact restrict_strictRestriction (h.subset.ssubset_of_ne hne)
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
N : Matroid α
h : N ≤r M
hne : N.E ≠ M.E
⊢ M ↾ N.E <r M
state_after: no goals
Theorem: one_div_le_one_div_of_le
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: simpa using inv_le_inv_of_le ha h
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
h : a ≤ b
⊢ 1 / b ≤ 1 / a
state_after: no goals
Theorem: List.IsSuffix.isInfix
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: rw [h, append_nil]
state_before: α✝ : Type u_1
l₁ l₂ : List α✝
x✝ : l₁ <:+ l₂
t : List α✝
h : t ++ l₁ = l₂
⊢ t ++ l₁ ++ [] = l₂
state_after: no goals
Theorem: Filter.atTop_finset_eq_iInf
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: refine le_antisymm (le_iInf fun i => le_principal_iff.2 <| mem_atTop ({i} : Finset α)) ?_
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
⊢ atTop = ⨅ x, 𝓟 (Ici {x})
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
⊢ ⨅ x, 𝓟 (Ici {x}) ≤ atTop

tactic: refine
  le_iInf fun s =>
    le_principal_iff.2 <| mem_iInf_of_iInter s.finite_toSet (fun i => mem_principal_self _) ?_
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
⊢ ⨅ x, 𝓟 (Ici {x}) ≤ atTop
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s : Finset α
⊢ ⋂ i, Ici {↑i} ⊆ Ici s

tactic: simp only [subset_def, mem_iInter, SetCoe.forall, mem_Ici, Finset.le_iff_subset,
  Finset.mem_singleton, Finset.subset_iff, forall_eq]
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s : Finset α
⊢ ⋂ i, Ici {↑i} ⊆ Ici s
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s : Finset α
⊢ ∀ (x : Finset α), (∀ x_1 ∈ ↑s, x_1 ∈ x) → ∀ ⦃x_1 : α⦄, x_1 ∈ s → x_1 ∈ x

tactic: exact fun t => id
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s : Finset α
⊢ ∀ (x : Finset α), (∀ x_1 ∈ ↑s, x_1 ∈ x) → ∀ ⦃x_1 : α⦄, x_1 ∈ s → x_1 ∈ x
state_after: no goals
Theorem: eq_inv_mul_iff_mul_eq
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [h, mul_inv_cancel_left]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : a = b⁻¹ * c
⊢ b * a = c
state_after: no goals

tactic: rw [← h, inv_mul_cancel_left]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : b * a = c
⊢ a = b⁻¹ * c
state_after: no goals
Theorem: DirectSum.lie_of_of_ne
File: Mathlib/Algebra/Lie/DirectSum.lean

tactic: refine DFinsupp.ext fun k => ?_
state_before: R : Type u
ι : Type v
inst✝³ : CommRing R
L : ι → Type w
inst✝² : (i : ι) → LieRing (L i)
inst✝¹ : (i : ι) → LieAlgebra R (L i)
inst✝ : DecidableEq ι
i j : ι
hij : i ≠ j
x : L i
y : L j
⊢ ⁅(of L i) x, (of L j) y⁆ = 0
state_after: R : Type u
ι : Type v
inst✝³ : CommRing R
L : ι → Type w
inst✝² : (i : ι) → LieRing (L i)
inst✝¹ : (i : ι) → LieAlgebra R (L i)
inst✝ : DecidableEq ι
i j : ι
hij : i ≠ j
x : L i
y : L j
k : ι
⊢ ⁅(of L i) x, (of L j) y⁆ k = 0 k

tactic: rw [bracket_apply]
state_before: R : Type u
ι : Type v
inst✝³ : CommRing R
L : ι → Type w
inst✝² : (i : ι) → LieRing (L i)
inst✝¹ : (i : ι) → LieAlgebra R (L i)
inst✝ : DecidableEq ι
i j : ι
hij : i ≠ j
x : L i
y : L j
k : ι
⊢ ⁅(of L i) x, (of L j) y⁆ k = 0 k
state_after: R : Type u
ι : Type v
inst✝³ : CommRing R
L : ι → Type w
inst✝² : (i : ι) → LieRing (L i)
inst✝¹ : (i : ι) → LieAlgebra R (L i)
inst✝ : DecidableEq ι
i j : ι
hij : i ≠ j
x : L i
y : L j
k : ι
⊢ ⁅((of L i) x) k, ((of L j) y) k⁆ = 0 k

tactic: obtain rfl | hik := Decidable.eq_or_ne i k
state_before: R : Type u
ι : Type v
inst✝³ : CommRing R
L : ι → Type w
inst✝² : (i : ι) → LieRing (L i)
inst✝¹ : (i : ι) → LieAlgebra R (L i)
inst✝ : DecidableEq ι
i j : ι
hij : i ≠ j
x : L i
y : L j
k : ι
⊢ ⁅((of L i) x) k, ((of L j) y) k⁆ = 0 k
state_after: case inl
R : Type u
ι : Type v
inst✝³ : CommRing R
L : ι → Type w
inst✝² : (i : ι) → LieRing (L i)
inst✝¹ : (i : ι) → LieAlgebra R (L i)
inst✝ : DecidableEq ι
i j : ι
hij : i ≠ j
x : L i
y : L j
⊢ ⁅((of L i) x) i, ((of L j) y) i⁆ = 0 i

case inr
R : Type u
ι : Type v
inst✝³ : CommRing R
L : ι → Type w
inst✝² : (i : ι) → LieRing (L i)
inst✝¹ : (i : ι) → LieAlgebra R (L i)
inst✝ : DecidableEq ι
i j : ι
hij : i ≠ j
x : L i
y : L j
k : ι
hik : i ≠ k
⊢ ⁅((of L i) x) k, ((of L j) y) k⁆ = 0 k

tactic: rw [of_eq_of_ne _ _ _ _ hij.symm, lie_zero, zero_apply]
state_before: case inl
R : Type u
ι : Type v
inst✝³ : CommRing R
L : ι → Type w
inst✝² : (i : ι) → LieRing (L i)
inst✝¹ : (i : ι) → LieAlgebra R (L i)
inst✝ : DecidableEq ι
i j : ι
hij : i ≠ j
x : L i
y : L j
⊢ ⁅((of L i) x) i, ((of L j) y) i⁆ = 0 i
state_after: no goals

tactic: rw [of_eq_of_ne _ _ _ _ hik, zero_lie, zero_apply]
state_before: case inr
R : Type u
ι : Type v
inst✝³ : CommRing R
L : ι → Type w
inst✝² : (i : ι) → LieRing (L i)
inst✝¹ : (i : ι) → LieAlgebra R (L i)
inst✝ : DecidableEq ι
i j : ι
hij : i ≠ j
x : L i
y : L j
k : ι
hik : i ≠ k
⊢ ⁅((of L i) x) k, ((of L j) y) k⁆ = 0 k
state_after: no goals
Theorem: UpperSemicontinuousAt.comp_continuousAt_of_eq
File: Mathlib/Topology/Semicontinuous.lean

tactic: rw [← hy] at hf
state_before: α : Type u_1
inst✝⁸ : TopologicalSpace α
β : Type u_2
inst✝⁷ : Preorder β
f✝ g✝ : α → β
x✝ : α
s t : Set α
y✝ z : β
γ : Type u_3
inst✝⁶ : LinearOrder γ
inst✝⁵ : TopologicalSpace γ
inst✝⁴ : OrderTopology γ
δ : Type u_4
inst✝³ : LinearOrder δ
inst✝² : TopologicalSpace δ
inst✝¹ : OrderTopology δ
ι : Type u_5
inst✝ : TopologicalSpace ι
f : α → β
g : ι → α
y : α
x : ι
hf : UpperSemicontinuousAt f y
hg : ContinuousAt g x
hy : g x = y
⊢ UpperSemicontinuousAt (fun x => f (g x)) x
state_after: α : Type u_1
inst✝⁸ : TopologicalSpace α
β : Type u_2
inst✝⁷ : Preorder β
f✝ g✝ : α → β
x✝ : α
s t : Set α
y✝ z : β
γ : Type u_3
inst✝⁶ : LinearOrder γ
inst✝⁵ : TopologicalSpace γ
inst✝⁴ : OrderTopology γ
δ : Type u_4
inst✝³ : LinearOrder δ
inst✝² : TopologicalSpace δ
inst✝¹ : OrderTopology δ
ι : Type u_5
inst✝ : TopologicalSpace ι
f : α → β
g : ι → α
y : α
x : ι
hf : UpperSemicontinuousAt f (g x)
hg : ContinuousAt g x
hy : g x = y
⊢ UpperSemicontinuousAt (fun x => f (g x)) x

tactic: exact comp_continuousAt hf hg
state_before: α : Type u_1
inst✝⁸ : TopologicalSpace α
β : Type u_2
inst✝⁷ : Preorder β
f✝ g✝ : α → β
x✝ : α
s t : Set α
y✝ z : β
γ : Type u_3
inst✝⁶ : LinearOrder γ
inst✝⁵ : TopologicalSpace γ
inst✝⁴ : OrderTopology γ
δ : Type u_4
inst✝³ : LinearOrder δ
inst✝² : TopologicalSpace δ
inst✝¹ : OrderTopology δ
ι : Type u_5
inst✝ : TopologicalSpace ι
f : α → β
g : ι → α
y : α
x : ι
hf : UpperSemicontinuousAt f (g x)
hg : ContinuousAt g x
hy : g x = y
⊢ UpperSemicontinuousAt (fun x => f (g x)) x
state_after: no goals
Theorem: FixedPoints.minpoly.ne_one
File: Mathlib/FieldTheory/Fixed.lean

tactic: rwa [H, Polynomial.eval₂_one] at this
state_before: M : Type u
inst✝⁵ : Monoid M
G : Type u
inst✝⁴ : Group G
F : Type v
inst✝³ : Field F
inst✝² : MulSemiringAction M F
inst✝¹ : MulSemiringAction G F
m : M
inst✝ : Fintype G
x : F
H : minpoly G F x = 1
this : Polynomial.eval₂ (subfield G F).subtype x (minpoly G F x) = 0
⊢ 1 = 0
state_after: no goals
Theorem: orderOf_pow_dvd
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [orderOf_dvd_iff_pow_eq_one, pow_right_comm, pow_orderOf_eq_one, one_pow]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n✝ m n : ℕ
⊢ orderOf (x ^ n) ∣ orderOf x
state_after: no goals
Theorem: CategoryTheory.NatTrans.mono_iff_mono_app
File: Mathlib/CategoryTheory/Adjunction/Evaluation.lean

tactic: constructor
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : ∀ (a b : C), HasCoproductsOfShape (a ⟶ b) D
F G : C ⥤ D
η : F ⟶ G
⊢ Mono η ↔ ∀ (c : C), Mono (η.app c)
state_after: case mp
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : ∀ (a b : C), HasCoproductsOfShape (a ⟶ b) D
F G : C ⥤ D
η : F ⟶ G
⊢ Mono η → ∀ (c : C), Mono (η.app c)

case mpr
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : ∀ (a b : C), HasCoproductsOfShape (a ⟶ b) D
F G : C ⥤ D
η : F ⟶ G
⊢ (∀ (c : C), Mono (η.app c)) → Mono η

tactic: intro h c
state_before: case mp
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : ∀ (a b : C), HasCoproductsOfShape (a ⟶ b) D
F G : C ⥤ D
η : F ⟶ G
⊢ Mono η → ∀ (c : C), Mono (η.app c)
state_after: case mp
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : ∀ (a b : C), HasCoproductsOfShape (a ⟶ b) D
F G : C ⥤ D
η : F ⟶ G
h : Mono η
c : C
⊢ Mono (η.app c)

tactic: exact (inferInstance : Mono (((evaluation _ _).obj c).map η))
state_before: case mp
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : ∀ (a b : C), HasCoproductsOfShape (a ⟶ b) D
F G : C ⥤ D
η : F ⟶ G
h : Mono η
c : C
⊢ Mono (η.app c)
state_after: no goals

tactic: intro _
state_before: case mpr
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : ∀ (a b : C), HasCoproductsOfShape (a ⟶ b) D
F G : C ⥤ D
η : F ⟶ G
⊢ (∀ (c : C), Mono (η.app c)) → Mono η
state_after: case mpr
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : ∀ (a b : C), HasCoproductsOfShape (a ⟶ b) D
F G : C ⥤ D
η : F ⟶ G
a✝ : ∀ (c : C), Mono (η.app c)
⊢ Mono η

tactic: apply NatTrans.mono_of_mono_app
state_before: case mpr
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : ∀ (a b : C), HasCoproductsOfShape (a ⟶ b) D
F G : C ⥤ D
η : F ⟶ G
a✝ : ∀ (c : C), Mono (η.app c)
⊢ Mono η
state_after: no goals
Theorem: CategoryTheory.NonPreadditiveAbelian.neg_neg
File: Mathlib/CategoryTheory/Abelian/NonPreadditive.lean

tactic: rw [neg_def, neg_def]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a : X ⟶ Y
⊢ - -a = a
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a : X ⟶ Y
⊢ 0 - (0 - a) = a

tactic: conv_lhs =>
  congr; rw [← sub_self a]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a : X ⟶ Y
⊢ 0 - (0 - a) = a
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a : X ⟶ Y
⊢ a - a - (0 - a) = a

tactic: rw [sub_sub_sub, sub_zero, sub_self, sub_zero]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a : X ⟶ Y
⊢ a - a - (0 - a) = a
state_after: no goals
Theorem: Irrational.mul_int
File: Mathlib/Data/Real/Irrational.lean

tactic: rw [← cast_intCast]
state_before: q : ℚ
x y : ℝ
h : Irrational x
m : ℤ
hm : m ≠ 0
⊢ Irrational (x * ↑m)
state_after: q : ℚ
x y : ℝ
h : Irrational x
m : ℤ
hm : m ≠ 0
⊢ Irrational (x * ↑↑m)

tactic: refine h.mul_rat ?_
state_before: q : ℚ
x y : ℝ
h : Irrational x
m : ℤ
hm : m ≠ 0
⊢ Irrational (x * ↑↑m)
state_after: q : ℚ
x y : ℝ
h : Irrational x
m : ℤ
hm : m ≠ 0
⊢ ↑m ≠ 0

tactic: rwa [Int.cast_ne_zero]
state_before: q : ℚ
x y : ℝ
h : Irrational x
m : ℤ
hm : m ≠ 0
⊢ ↑m ≠ 0
state_after: no goals
Theorem: Bool.and_intro
File: Mathlib/Data/Bool/Basic.lean

tactic: decide
state_before: ⊢ ∀ {a b : Bool}, a = true → b = true → (a && b) = true
state_after: no goals
Theorem: CategoryTheory.Limits.biprod.associator_natural
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: aesop_cat
state_before: J : Type w
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
D : Type uD
inst✝² : Category.{uD', uD} D
inst✝¹ : HasZeroMorphisms D
P Q : C
inst✝ : HasBinaryBiproducts C
U V W X Y Z : C
f : U ⟶ X
g : V ⟶ Y
h : W ⟶ Z
⊢ map (map f g) h ≫ (associator X Y Z).hom = (associator U V W).hom ≫ map f (map g h)
state_after: no goals
Theorem: Int.cast_natAbs
File: Mathlib/Algebra/Order/Ring/Cast.lean

tactic: cases n
state_before: R : Type u_1
inst✝ : LinearOrderedRing R
a b n : ℤ
x : R
⊢ ↑n.natAbs = ↑|n|
state_after: case ofNat
R : Type u_1
inst✝ : LinearOrderedRing R
a b : ℤ
x : R
a✝ : ℕ
⊢ ↑(ofNat a✝).natAbs = ↑|ofNat a✝|

case negSucc
R : Type u_1
inst✝ : LinearOrderedRing R
a b : ℤ
x : R
a✝ : ℕ
⊢ ↑-[a✝+1].natAbs = ↑|-[a✝+1]|

tactic: simp
state_before: case ofNat
R : Type u_1
inst✝ : LinearOrderedRing R
a b : ℤ
x : R
a✝ : ℕ
⊢ ↑(ofNat a✝).natAbs = ↑|ofNat a✝|
state_after: no goals

tactic: rw [abs_eq_natAbs, natAbs_negSucc, cast_succ, cast_natCast, cast_succ]
state_before: case negSucc
R : Type u_1
inst✝ : LinearOrderedRing R
a b : ℤ
x : R
a✝ : ℕ
⊢ ↑-[a✝+1].natAbs = ↑|-[a✝+1]|
state_after: no goals