ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Limits.inl_pushoutZeroZeroIso_inv
File: Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : HasBinaryCoproduct X Y
⊢ coprod.inl ≫ (pushoutZeroZeroIso X Y).inv = pushout.inl 0 0
state_after: no goals
tactic: simp [Iso.comp_inv_eq]
Theorem: CategoryTheory.Pretriangulated.isIso₃_of_isIso₁₂
File: Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (shiftFunctor C n).Additive
hC : Pretriangulated C
T T' : Triangle C
φ : T ⟶ T'
hT : T ∈ distinguishedTriangles
hT' : T' ∈ distinguishedTriangles
h₁ : IsIso φ.hom₁
h₂ : IsIso φ.hom₂
⊢ IsIso ((rotate C).map φ).hom₃
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (shiftFunctor C n).Additive
hC : Pretriangulated C
T T' : Triangle C
φ : T ⟶ T'
hT : T ∈ distinguishedTriangles
hT' : T' ∈ distinguishedTriangles
h₁ : IsIso φ.hom₁
h₂ : IsIso φ.hom₂
⊢ IsIso ((shiftFunctor C 1).map φ.hom₁)
tactic: dsimp
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (shiftFunctor C n).Additive
hC : Pretriangulated C
T T' : Triangle C
φ : T ⟶ T'
hT : T ∈ distinguishedTriangles
hT' : T' ∈ distinguishedTriangles
h₁ : IsIso φ.hom₁
h₂ : IsIso φ.hom₂
⊢ IsIso ((shiftFunctor C 1).map φ.hom₁)
state_after: no goals
tactic: infer_instance
Theorem: hammingDist_lt_one
File: Mathlib/InformationTheory/Hamming.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
β : ι → Type u_3
inst✝² : Fintype ι
inst✝¹ : (i : ι) → DecidableEq (β i)
γ : ι → Type u_4
inst✝ : (i : ι) → DecidableEq (γ i)
x y : (i : ι) → β i
⊢ hammingDist x y < 1 ↔ x = y
state_after: no goals
tactic: rw [Nat.lt_one_iff, hammingDist_eq_zero]
Theorem: EuclideanGeometry.oangle_self_right
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ : P
⊢ ∡ p₁ p₂ p₂ = 0
state_after: no goals
tactic: simp [oangle]
Theorem: ContinuousMap.exists_mem_subalgebra_near_continuous_of_separatesPoints
File: Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean

Proof steps:
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
w : A.SeparatesPoints
f : X → ℝ
c : Continuous f
ε : ℝ
pos : 0 < ε
⊢ ∃ g, ∀ (x : X), ‖↑g x - f x‖ < ε
state_after: case intro
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
w : A.SeparatesPoints
f : X → ℝ
c : Continuous f
ε : ℝ
pos : 0 < ε
g : ↥A
b : ‖↑g - { toFun := f, continuous_toFun := c }‖ < ε
⊢ ∃ g, ∀ (x : X), ‖↑g x - f x‖ < ε
tactic: obtain ⟨g, b⟩ := exists_mem_subalgebra_near_continuousMap_of_separatesPoints A w ⟨f, c⟩ ε pos
state_before: case intro
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
w : A.SeparatesPoints
f : X → ℝ
c : Continuous f
ε : ℝ
pos : 0 < ε
g : ↥A
b : ‖↑g - { toFun := f, continuous_toFun := c }‖ < ε
⊢ ∃ g, ∀ (x : X), ‖↑g x - f x‖ < ε
state_after: case h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
w : A.SeparatesPoints
f : X → ℝ
c : Continuous f
ε : ℝ
pos : 0 < ε
g : ↥A
b : ‖↑g - { toFun := f, continuous_toFun := c }‖ < ε
⊢ ∀ (x : X), ‖↑g x - f x‖ < ε
tactic: use g
state_before: case h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
A : Subalgebra ℝ C(X, ℝ)
w : A.SeparatesPoints
f : X → ℝ
c : Continuous f
ε : ℝ
pos : 0 < ε
g : ↥A
b : ‖↑g - { toFun := f, continuous_toFun := c }‖ < ε
⊢ ∀ (x : X), ‖↑g x - f x‖ < ε
state_after: no goals
tactic: rwa [norm_lt_iff _ pos] at b
Theorem: MeasureTheory.SimpleFunc.range_one
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : Nonempty α
inst✝ : One β
x : β
⊢ x ∈ SimpleFunc.range 1 ↔ x ∈ {1}
state_after: no goals
tactic: simp [eq_comm]
Theorem: Basis.SmithNormalForm.repr_comp_embedding_eq_smul
File: Mathlib/LinearAlgebra/FreeModule/PID.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : IsPrincipalIdealRing R
M : Type u_3
inst✝¹ : AddCommGroup M
inst✝ : Module R M
b : ι → M
n : ℕ
N : Submodule R M
snf : SmithNormalForm N ι n
m : ↥N
⊢ ⇑(snf.bM.repr ↑m) ∘ ⇑snf.f = snf.a • ⇑(snf.bN.repr m)
state_after: case h
ι : Type u_1
R : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : IsPrincipalIdealRing R
M : Type u_3
inst✝¹ : AddCommGroup M
inst✝ : Module R M
b : ι → M
n : ℕ
N : Submodule R M
snf : SmithNormalForm N ι n
m : ↥N
i : Fin n
⊢ (⇑(snf.bM.repr ↑m) ∘ ⇑snf.f) i = (snf.a • ⇑(snf.bN.repr m)) i
tactic: ext i
state_before: case h
ι : Type u_1
R : Type u_2
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
inst✝² : IsPrincipalIdealRing R
M : Type u_3
inst✝¹ : AddCommGroup M
inst✝ : Module R M
b : ι → M
n : ℕ
N : Submodule R M
snf : SmithNormalForm N ι n
m : ↥N
i : Fin n
⊢ (⇑(snf.bM.repr ↑m) ∘ ⇑snf.f) i = (snf.a • ⇑(snf.bN.repr m)) i
state_after: no goals
tactic: simp [Pi.smul_apply (snf.a i)]
Theorem: Algebra.commute_of_mem_adjoin_singleton_of_commute
File: Mathlib/RingTheory/Adjoin/Basic.lean

Proof steps:
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
inst✝⁸ : CommSemiring R
inst✝⁷ : CommSemiring S
inst✝⁶ : Semiring A
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R S
inst✝³ : Algebra R A
inst✝² : Algebra S A
inst✝¹ : Algebra R B
inst✝ : IsScalarTower R S A
s t : Set A
a b c : A
hc : c ∈ adjoin R {b}
h : Commute a b
⊢ ∀ b_1 ∈ {b}, Commute a b_1
state_after: no goals
tactic: simpa
Theorem: TruncatedWittVector.commutes'
File: Mathlib/RingTheory/WittVector/Compare.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
m : ℕ
hm : n ≤ m
x : ZMod (p ^ m)
⊢ ((truncate hm).comp (zmodEquivTrunc p m).toRingHom) x = (zmodEquivTrunc p n) ((ZMod.castHom ⋯ (ZMod (p ^ n))) x)
state_after: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
m : ℕ
hm : n ≤ m
x : ZMod (p ^ m)
⊢ ((zmodEquivTrunc p n).toRingHom.comp (ZMod.castHom ⋯ (ZMod (p ^ n)))) x =
    (zmodEquivTrunc p n) ((ZMod.castHom ⋯ (ZMod (p ^ n))) x)
tactic: rw [commutes _ _ hm]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
m : ℕ
hm : n ≤ m
x : ZMod (p ^ m)
⊢ ((zmodEquivTrunc p n).toRingHom.comp (ZMod.castHom ⋯ (ZMod (p ^ n)))) x =
    (zmodEquivTrunc p n) ((ZMod.castHom ⋯ (ZMod (p ^ n))) x)
state_after: no goals
tactic: rfl
Theorem: CliffordAlgebra.involute_comp_involute
File: Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
⊢ involute.comp involute = AlgHom.id R (CliffordAlgebra Q)
state_after: case a.h
R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x✝ : M
⊢ ((involute.comp involute).toLinearMap ∘ₗ ι Q) x✝ = ((AlgHom.id R (CliffordAlgebra Q)).toLinearMap ∘ₗ ι Q) x✝
tactic: ext
state_before: case a.h
R : Type u_1
inst✝² : CommRing R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x✝ : M
⊢ ((involute.comp involute).toLinearMap ∘ₗ ι Q) x✝ = ((AlgHom.id R (CliffordAlgebra Q)).toLinearMap ∘ₗ ι Q) x✝
state_after: no goals
tactic: simp
Theorem: AddGroupFilterBasis.nhds_zero_eq
File: Mathlib/Topology/Algebra/FilterBasis.lean

Proof steps:
state_before: G : Type u
inst✝ : Group G
B✝ B : GroupFilterBasis G
⊢ 𝓝 1 = toFilterBasis.filter
state_after: G : Type u
inst✝ : Group G
B✝ B : GroupFilterBasis G
⊢ B.N 1 = toFilterBasis.filter
tactic: rw [B.nhds_eq]
state_before: G : Type u
inst✝ : Group G
B✝ B : GroupFilterBasis G
⊢ B.N 1 = toFilterBasis.filter
state_after: G : Type u
inst✝ : Group G
B✝ B : GroupFilterBasis G
⊢ map (fun y => y) toFilterBasis.filter = toFilterBasis.filter
tactic: simp only [N, one_mul]
state_before: G : Type u
inst✝ : Group G
B✝ B : GroupFilterBasis G
⊢ map (fun y => y) toFilterBasis.filter = toFilterBasis.filter
state_after: no goals
tactic: exact map_id
Theorem: tsum_setProd_singleton_left
File: Mathlib/Topology/Algebra/InfiniteSum/Constructions.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
b : β
t : Set γ
f : β × γ → α
⊢ ∏' (x : ↑({b} ×ˢ t)), f ↑x = ∏' (c : ↑t), f (b, ↑c)
state_after: no goals
tactic: rw [tprod_congr_set_coe _ Set.singleton_prod, tprod_image _ (Prod.mk.inj_left b).injOn]
Theorem: Associated.of_mul_right
File: Mathlib/Algebra/Associated/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
a b c d : α
⊢ a * b ~ᵤ c * d → b ~ᵤ d → b ≠ 0 → a ~ᵤ c
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
a b c d : α
⊢ b * a ~ᵤ d * c → b ~ᵤ d → b ≠ 0 → a ~ᵤ c
tactic: rw [mul_comm a, mul_comm c]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
a b c d : α
⊢ b * a ~ᵤ d * c → b ~ᵤ d → b ≠ 0 → a ~ᵤ c
state_after: no goals
tactic: exact Associated.of_mul_left
Theorem: Finset.mem_erase_of_ne_of_mem
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
⊢ a ≠ b → a ∈ s → a ∈ s.erase b
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
⊢ a ≠ b → a ∈ s → a ≠ b ∧ a ∈ s
tactic: simp only [mem_erase]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
⊢ a ≠ b → a ∈ s → a ≠ b ∧ a ∈ s
state_after: no goals
tactic: exact And.intro
Theorem: MeasureTheory.SignedMeasure.jordanDecomposition_add_withDensity_mutuallySingular
File: Mathlib/MeasureTheory/Decomposition/SignedLebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
s t : SignedMeasure α
f : α → ℝ
hf : Measurable f
htμ : t ⟂ᵥ μ.toENNRealVectorMeasure
⊢ (t.toJordanDecomposition.posPart + μ.withDensity fun x => ENNReal.ofReal (f x)) ⟂ₘ
    t.toJordanDecomposition.negPart + μ.withDensity fun x => ENNReal.ofReal (-f x)
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
s t : SignedMeasure α
f : α → ℝ
hf : Measurable f
htμ : t.toJordanDecomposition.posPart ⟂ₘ μ ∧ t.toJordanDecomposition.negPart ⟂ₘ μ
⊢ (t.toJordanDecomposition.posPart + μ.withDensity fun x => ENNReal.ofReal (f x)) ⟂ₘ
    t.toJordanDecomposition.negPart + μ.withDensity fun x => ENNReal.ofReal (-f x)
tactic: rw [mutuallySingular_ennreal_iff, totalVariation_mutuallySingular_iff,
    VectorMeasure.ennrealToMeasure_toENNRealVectorMeasure] at htμ
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
s t : SignedMeasure α
f : α → ℝ
hf : Measurable f
htμ : t.toJordanDecomposition.posPart ⟂ₘ μ ∧ t.toJordanDecomposition.negPart ⟂ₘ μ
⊢ (t.toJordanDecomposition.posPart + μ.withDensity fun x => ENNReal.ofReal (f x)) ⟂ₘ
    t.toJordanDecomposition.negPart + μ.withDensity fun x => ENNReal.ofReal (-f x)
state_after: no goals
tactic: exact
    ((JordanDecomposition.mutuallySingular _).add_right
          (htμ.1.mono_ac (refl _) (withDensity_absolutelyContinuous _ _))).add_left
      ((htμ.2.symm.mono_ac (withDensity_absolutelyContinuous _ _) (refl _)).add_right
        (withDensity_ofReal_mutuallySingular hf))
Theorem: Path.Homotopic.pi_proj
File: Mathlib/Topology/Homotopy/Product.lean

Proof steps:
state_before: ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
p : Homotopic.Quotient as bs
⊢ (pi fun i => proj i p) = p
state_after: case h
ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
a✝ : Path as bs
⊢ (pi fun i => proj i ⟦a✝⟧) = ⟦a✝⟧
tactic: induction p using Quotient.inductionOn
state_before: case h
ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
a✝ : Path as bs
⊢ (pi fun i => proj i ⟦a✝⟧) = ⟦a✝⟧
state_after: case h
ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
a✝ : Path as bs
⊢ (pi fun i => ⟦a✝.map ⋯⟧) = ⟦a✝⟧
tactic: simp_rw [proj, ← Path.Homotopic.map_lift]
state_before: case h
ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
a✝ : Path as bs
⊢ (pi fun i => ⟦a✝.map ⋯⟧) = ⟦a✝⟧
state_after: case h
ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
a✝ : Path as bs
⊢ ⟦Path.pi fun i => a✝.map ⋯⟧ = ⟦a✝⟧
tactic: erw [pi_lift]
state_before: case h
ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
a✝ : Path as bs
⊢ ⟦Path.pi fun i => a✝.map ⋯⟧ = ⟦a✝⟧
state_after: no goals
tactic: congr
Theorem: AddMonoidAlgebra.singleZeroRingHom_apply
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

Proof steps:
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : AddMonoid G
x y : k
⊢ { toFun := (↑__src✝).toFun, map_one' := ⋯ }.toFun (x * y) =
    { toFun := (↑__src✝).toFun, map_one' := ⋯ }.toFun x * { toFun := (↑__src✝).toFun, map_one' := ⋯ }.toFun y
state_after: no goals
tactic: simp only [singleAddHom, single_mul_single, zero_add]
Theorem: Bool.exists_bool'
File: Mathlib/Data/Bool/Basic.lean

Proof steps:
state_before: p : Bool → Prop
b : Bool
x✝ : ∃ x, p x
x : Bool
hx : p x
⊢ p b ∨ p !b
state_after: no goals
tactic: cases x <;> cases b <;> first | exact .inl ‹_› | exact .inr ‹_›
state_before: p : Bool → Prop
b : Bool
h : p b ∨ p !b
⊢ ∃ x, p x
state_after: no goals
tactic: cases h <;> exact ⟨_, ‹_›⟩
Theorem: CategoryTheory.Limits.image.compIso_hom_comp_image_ι
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
X Y : C
f : X ⟶ Y
Z : C
g : Y ⟶ Z
inst✝² : HasEqualizers C
inst✝¹ : HasImage f
inst✝ : IsIso g
⊢ (compIso f g).hom ≫ ι (f ≫ g) = ι f ≫ g
state_after: case w
C : Type u
inst✝³ : Category.{v, u} C
X Y : C
f : X ⟶ Y
Z : C
g : Y ⟶ Z
inst✝² : HasEqualizers C
inst✝¹ : HasImage f
inst✝ : IsIso g
⊢ factorThruImage f ≫ (compIso f g).hom ≫ ι (f ≫ g) = factorThruImage f ≫ ι f ≫ g
tactic: ext
state_before: case w
C : Type u
inst✝³ : Category.{v, u} C
X Y : C
f : X ⟶ Y
Z : C
g : Y ⟶ Z
inst✝² : HasEqualizers C
inst✝¹ : HasImage f
inst✝ : IsIso g
⊢ factorThruImage f ≫ (compIso f g).hom ≫ ι (f ≫ g) = factorThruImage f ≫ ι f ≫ g
state_after: no goals
tactic: simp [image.compIso]
Theorem: IsCompact.measure_eq_iInf_isOpen
File: Mathlib/MeasureTheory/Measure/Regular.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : MeasurableSpace α
inst✝⁴ : TopologicalSpace α
μ : Measure α
inst✝³ : μ.InnerRegularCompactLTTop
inst✝² : IsLocallyFiniteMeasure μ
inst✝¹ : R1Space α
inst✝ : BorelSpace α
K : Set α
hK : IsCompact K
⊢ μ K = ⨅ U, ⨅ (_ : K ⊆ U), ⨅ (_ : IsOpen U), μ U
state_after: case a
α : Type u_1
β : Type u_2
inst✝⁵ : MeasurableSpace α
inst✝⁴ : TopologicalSpace α
μ : Measure α
inst✝³ : μ.InnerRegularCompactLTTop
inst✝² : IsLocallyFiniteMeasure μ
inst✝¹ : R1Space α
inst✝ : BorelSpace α
K : Set α
hK : IsCompact K
⊢ μ K ≤ ⨅ U, ⨅ (_ : K ⊆ U), ⨅ (_ : IsOpen U), μ U

case a
α : Type u_1
β : Type u_2
inst✝⁵ : MeasurableSpace α
inst✝⁴ : TopologicalSpace α
μ : Measure α
inst✝³ : μ.InnerRegularCompactLTTop
inst✝² : IsLocallyFiniteMeasure μ
inst✝¹ : R1Space α
inst✝ : BorelSpace α
K : Set α
hK : IsCompact K
⊢ ⨅ U, ⨅ (_ : K ⊆ U), ⨅ (_ : IsOpen U), μ U ≤ μ K
tactic: apply le_antisymm
Theorem: AlgHom.eqOn_sup
File: Mathlib/Algebra/Algebra/Subalgebra/Basic.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : Semiring B
inst✝² : Algebra R B
F : Type u_4
inst✝¹ : FunLike F A B
inst✝ : AlgHomClass F R A B
φ ψ : F
S T : Subalgebra R A
hS : Set.EqOn ⇑φ ⇑ψ ↑S
hT : Set.EqOn ⇑φ ⇑ψ ↑T
⊢ Set.EqOn ⇑φ ⇑ψ ↑(S ⊔ T)
state_after: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : Semiring B
inst✝² : Algebra R B
F : Type u_4
inst✝¹ : FunLike F A B
inst✝ : AlgHomClass F R A B
φ ψ : F
S T : Subalgebra R A
hS : S ≤ equalizer φ ψ
hT : T ≤ equalizer φ ψ
⊢ S ⊔ T ≤ equalizer φ ψ
tactic: rw [← le_equalizer] at hS hT ⊢
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : Semiring B
inst✝² : Algebra R B
F : Type u_4
inst✝¹ : FunLike F A B
inst✝ : AlgHomClass F R A B
φ ψ : F
S T : Subalgebra R A
hS : S ≤ equalizer φ ψ
hT : T ≤ equalizer φ ψ
⊢ S ⊔ T ≤ equalizer φ ψ
state_after: no goals
tactic: exact sup_le hS hT
Theorem: differentiableOn_univ
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
⊢ DifferentiableOn 𝕜 f univ ↔ Differentiable 𝕜 f
state_after: no goals
tactic: simp only [DifferentiableOn, Differentiable, differentiableWithinAt_univ, mem_univ,
    forall_true_left]
Theorem: Range.isAddSubmonoid
File: Mathlib/Deprecated/Submonoid.lean

Proof steps:
state_before: M : Type u_1
inst✝² : Monoid M
s : Set M
A : Type u_2
inst✝¹ : AddMonoid A
t : Set A
γ : Type u_3
inst✝ : Monoid γ
f : M → γ
hf : IsMonoidHom f
⊢ IsSubmonoid (Set.range f)
state_after: M : Type u_1
inst✝² : Monoid M
s : Set M
A : Type u_2
inst✝¹ : AddMonoid A
t : Set A
γ : Type u_3
inst✝ : Monoid γ
f : M → γ
hf : IsMonoidHom f
⊢ IsSubmonoid (f '' Set.univ)
tactic: rw [← Set.image_univ]
state_before: M : Type u_1
inst✝² : Monoid M
s : Set M
A : Type u_2
inst✝¹ : AddMonoid A
t : Set A
γ : Type u_3
inst✝ : Monoid γ
f : M → γ
hf : IsMonoidHom f
⊢ IsSubmonoid (f '' Set.univ)
state_after: no goals
tactic: exact Univ.isSubmonoid.image hf
Theorem: Polynomial.natDegree_eq_one
File: Mathlib/Algebra/Polynomial/Degree/Lemmas.lean

Proof steps:
state_before: R : Type u
S : Type v
ι : Type w
a✝ b : R
m n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p q : R[X]
a : R
⊢ p.natDegree = 1 ↔ ∃ a, a ≠ 0 ∧ ∃ b, C a * X + C b = p
state_after: case refine_1
R : Type u
S : Type v
ι : Type w
a✝ b : R
m n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p q : R[X]
a : R
hp : p.natDegree = 1
h : p.coeff 1 = 0
⊢ False

case refine_2
R : Type u
S : Type v
ι : Type w
a✝ b : R
m n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p q : R[X]
a : R
hp : p.natDegree = 1
⊢ C (p.coeff 1) * X + C (p.coeff 0) = p

case refine_3
R : Type u
S : Type v
ι : Type w
a✝ b : R
m n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p q : R[X]
a : R
⊢ (∃ a, a ≠ 0 ∧ ∃ b, C a * X + C b = p) → p.natDegree = 1
tactic: refine ⟨fun hp ↦ ⟨p.coeff 1, fun h ↦ ?_, p.coeff 0, ?_⟩, ?_⟩
Theorem: Submodule.sub_mem_iff_left
File: Mathlib/Algebra/Module/Submodule/Basic.lean

Proof steps:
state_before: G : Type u''
S : Type u'
R : Type u
M : Type v
ι : Type w
inst✝¹ : Ring R
inst✝ : AddCommGroup M
module_M : Module R M
p p' : Submodule R M
r : R
x y : M
hy : y ∈ p
⊢ x - y ∈ p ↔ x ∈ p
state_after: no goals
tactic: rw [sub_eq_add_neg, p.add_mem_iff_left (p.neg_mem hy)]
Theorem: RingHom.finitePresentation_stableUnderComposition
File: Mathlib/RingTheory/RingHom/FinitePresentation.lean

Proof steps:
state_before: ⊢ StableUnderComposition @FinitePresentation
state_after: R S T : Type u_1
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
f : R →+* S
g : S →+* T
hf : f.FinitePresentation
hg : g.FinitePresentation
⊢ (g.comp f).FinitePresentation
tactic: introv R hf hg
state_before: R S T : Type u_1
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
f : R →+* S
g : S →+* T
hf : f.FinitePresentation
hg : g.FinitePresentation
⊢ (g.comp f).FinitePresentation
state_after: no goals
tactic: exact hg.comp hf
Theorem: List.Sublist.countP_le
File: .lake/packages/batteries/Batteries/Data/List/Count.lean

Proof steps:
state_before: α : Type u_1
p q : α → Bool
l₁ l₂ : List α
s : l₁ <+ l₂
⊢ countP p l₁ ≤ countP p l₂
state_after: α : Type u_1
p q : α → Bool
l₁ l₂ : List α
s : l₁ <+ l₂
⊢ (List.filter p l₁).length ≤ (List.filter p l₂).length
tactic: simp only [countP_eq_length_filter]
state_before: α : Type u_1
p q : α → Bool
l₁ l₂ : List α
s : l₁ <+ l₂
⊢ (List.filter p l₁).length ≤ (List.filter p l₂).length
state_after: no goals
tactic: apply s.filter _ |>.length_le
Theorem: Equiv.Perm.swap_induction_on
File: Mathlib/GroupTheory/Perm/Sign.lean

Proof steps:
state_before: α : Type u
inst✝¹ : DecidableEq α
β : Type v
inst✝ : Finite α
P : Perm α → Prop
f : Perm α
⊢ P 1 → (∀ (f : Perm α) (x y : α), x ≠ y → P f → P (swap x y * f)) → P f
state_after: case intro
α : Type u
inst✝¹ : DecidableEq α
β : Type v
inst✝ : Finite α
P : Perm α → Prop
f : Perm α
val✝ : Fintype α
⊢ P 1 → (∀ (f : Perm α) (x y : α), x ≠ y → P f → P (swap x y * f)) → P f
tactic: cases nonempty_fintype α
state_before: case intro
α : Type u
inst✝¹ : DecidableEq α
β : Type v
inst✝ : Finite α
P : Perm α → Prop
f : Perm α
val✝ : Fintype α
⊢ P 1 → (∀ (f : Perm α) (x y : α), x ≠ y → P f → P (swap x y * f)) → P f
state_after: case intro.mk
α : Type u
inst✝¹ : DecidableEq α
β : Type v
inst✝ : Finite α
P : Perm α → Prop
f : Perm α
val✝ : Fintype α
l : List (Perm α)
hl : l.prod = f ∧ ∀ g ∈ l, g.IsSwap
⊢ P 1 → (∀ (f : Perm α) (x y : α), x ≠ y → P f → P (swap x y * f)) → P f
tactic: cases' (truncSwapFactors f).out with l hl
state_before: case intro.mk
α : Type u
inst✝¹ : DecidableEq α
β : Type v
inst✝ : Finite α
P : Perm α → Prop
f : Perm α
val✝ : Fintype α
l : List (Perm α)
hl : l.prod = f ∧ ∀ g ∈ l, g.IsSwap
⊢ P 1 → (∀ (f : Perm α) (x y : α), x ≠ y → P f → P (swap x y * f)) → P f
state_after: case intro.mk.nil
α : Type u
inst✝¹ : DecidableEq α
β : Type v
inst✝ : Finite α
P : Perm α → Prop
val✝ : Fintype α
f : Perm α
hl : [].prod = f ∧ ∀ g ∈ [], g.IsSwap
⊢ P 1 → (∀ (f : Perm α) (x y : α), x ≠ y → P f → P (swap x y * f)) → P f

case intro.mk.cons
α : Type u
inst✝¹ : DecidableEq α
β : Type v
inst✝ : Finite α
P : Perm α → Prop
val✝ : Fintype α
g : Perm α
l : List (Perm α)
ih :
  ∀ (f : Perm α),
    (l.prod = f ∧ ∀ g ∈ l, g.IsSwap) → P 1 → (∀ (f : Perm α) (x y : α), x ≠ y → P f → P (swap x y * f)) → P f
f : Perm α
hl : (g :: l).prod = f ∧ ∀ g_1 ∈ g :: l, g_1.IsSwap
⊢ P 1 → (∀ (f : Perm α) (x y : α), x ≠ y → P f → P (swap x y * f)) → P f
tactic: induction' l with g l ih generalizing f
Theorem: NormedField.nhdsWithin_isUnit_neBot
File: Mathlib/Analysis/Normed/Field/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝ : NontriviallyNormedField α
⊢ (𝓝[{x | IsUnit x}] 0).NeBot
state_after: no goals
tactic: simpa only [isUnit_iff_ne_zero] using punctured_nhds_neBot (0 : α)