ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Complex.analyticOn_univ_iff_differentiable
File: Mathlib/Analysis/Complex/CauchyIntegral.lean

Proof steps:
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
⊢ AnalyticOn ℂ f univ ↔ Differentiable ℂ f
state_after: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
⊢ AnalyticOn ℂ f univ ↔ DifferentiableOn ℂ f univ
tactic: simp only [← differentiableOn_univ]
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
⊢ AnalyticOn ℂ f univ ↔ DifferentiableOn ℂ f univ
state_after: no goals
tactic: exact analyticOn_iff_differentiableOn isOpen_univ
Theorem: Cycle.reverse_reverse
File: Mathlib/Data/List/Cycle.lean

Proof steps:
state_before: α : Type u_1
s : Cycle α
x✝ : List α
⊢ (reverse (Quot.mk Setoid.r x✝)).reverse = Quot.mk Setoid.r x✝
state_after: no goals
tactic: simp
Theorem: BoundedContinuousFunction.toReal_lintegral_coe_eq_integral
File: Mathlib/MeasureTheory/Integral/BoundedContinuousFunction.lean

Proof steps:
state_before: X : Type u_1
inst✝³ : MeasurableSpace X
inst✝² : TopologicalSpace X
inst✝¹ : OpensMeasurableSpace X
μ✝ : Measure X
inst✝ : IsFiniteMeasure μ✝
f : X →ᵇ ℝ≥0
μ : Measure X
⊢ (∫⁻ (x : X), ↑(f x) ∂μ).toReal = ∫ (x : X), ↑(f x) ∂μ
state_after: X : Type u_1
inst✝³ : MeasurableSpace X
inst✝² : TopologicalSpace X
inst✝¹ : OpensMeasurableSpace X
μ✝ : Measure X
inst✝ : IsFiniteMeasure μ✝
f : X →ᵇ ℝ≥0
μ : Measure X
⊢ (∫⁻ (x : X), ↑(f x) ∂μ).toReal = (∫⁻ (a : X), ENNReal.ofReal ↑(f a) ∂μ).toReal

X : Type u_1
inst✝³ : MeasurableSpace X
inst✝² : TopologicalSpace X
inst✝¹ : OpensMeasurableSpace X
μ✝ : Measure X
inst✝ : IsFiniteMeasure μ✝
f : X →ᵇ ℝ≥0
μ : Measure X
⊢ 0 ≤ᶠ[ae μ] fun x => ↑(f x)
tactic: rw [integral_eq_lintegral_of_nonneg_ae _ (by simpa [Function.comp_apply] using
        (NNReal.continuous_coe.comp f.continuous).measurable.aestronglyMeasurable)]
Theorem: Module.comap_eval_surjective
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: K : Type uK
V : Type uV
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
⊢ Function.Surjective (comap (eval K V))
state_after: case hf
K : Type uK
V : Type uV
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
⊢ Function.Injective ⇑(eval K V)
tactic: apply Submodule.comap_surjective_of_injective
state_before: case hf
K : Type uK
V : Type uV
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
⊢ Function.Injective ⇑(eval K V)
state_after: case hf
K : Type uK
V : Type uV
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
⊢ ker (eval K V) = ⊥
tactic: rw [← LinearMap.ker_eq_bot]
state_before: case hf
K : Type uK
V : Type uV
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
⊢ ker (eval K V) = ⊥
state_after: no goals
tactic: exact eval_ker K V
Theorem: Function.Antiperiodic.eq
File: Mathlib/Algebra/Periodic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddZeroClass α
inst✝ : Neg β
h : Antiperiodic f c
⊢ f c = -f 0
state_after: no goals
tactic: simpa only [zero_add] using h 0
Theorem: Finsupp.filter_smul
File: Mathlib/Data/Finsupp/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
p : α → Prop
inst✝² : DecidablePred p
x✝ : Monoid R
inst✝¹ : AddMonoid M
inst✝ : DistribMulAction R M
b : R
v : α →₀ M
⊢ (fun f => ⇑f) (filter p (b • v)) = (fun f => ⇑f) (b • filter p v)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
p : α → Prop
inst✝² : DecidablePred p
x✝ : Monoid R
inst✝¹ : AddMonoid M
inst✝ : DistribMulAction R M
b : R
v : α →₀ M
⊢ {x | p x}.indicator (b • ⇑v) = b • {x | p x}.indicator ⇑v
tactic: simp only [filter_eq_indicator, coe_smul]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
p : α → Prop
inst✝² : DecidablePred p
x✝ : Monoid R
inst✝¹ : AddMonoid M
inst✝ : DistribMulAction R M
b : R
v : α →₀ M
⊢ {x | p x}.indicator (b • ⇑v) = b • {x | p x}.indicator ⇑v
state_after: no goals
tactic: exact Set.indicator_const_smul { x | p x } b v
Theorem: AddUnits.topology_eq_inf
File: Mathlib/Topology/Algebra/Constructions.lean

Proof steps:
state_before: M : Type u_1
X : Type u_2
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : TopologicalSpace X
⊢ instTopologicalSpaceUnits = TopologicalSpace.induced val inst✝² ⊓ TopologicalSpace.induced (fun u => ↑u⁻¹) inst✝²
state_after: M : Type u_1
X : Type u_2
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : TopologicalSpace X
⊢ TopologicalSpace.induced (Prod.fst ∘ ⇑(embedProduct M)) inst✝² ⊓
      TopologicalSpace.induced ((unop ∘ Prod.snd) ∘ ⇑(embedProduct M)) inst✝² =
    TopologicalSpace.induced val inst✝² ⊓ TopologicalSpace.induced (fun u => ↑u⁻¹) inst✝²
tactic: simp only [inducing_embedProduct.1, instTopologicalSpaceProd, induced_inf,
    instTopologicalSpaceMulOpposite, induced_compose]
state_before: M : Type u_1
X : Type u_2
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : TopologicalSpace X
⊢ TopologicalSpace.induced (Prod.fst ∘ ⇑(embedProduct M)) inst✝² ⊓
      TopologicalSpace.induced ((unop ∘ Prod.snd) ∘ ⇑(embedProduct M)) inst✝² =
    TopologicalSpace.induced val inst✝² ⊓ TopologicalSpace.induced (fun u => ↑u⁻¹) inst✝²
state_after: no goals
tactic: rfl
Theorem: AddSubmonoid.mrange_inl_sup_mrange_inr
File: Mathlib/Algebra/Group/Submonoid/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
⊢ mrange (inl M N) ⊔ mrange (inr M N) = ⊤
state_after: no goals
tactic: simp only [mrange_inl, mrange_inr, prod_bot_sup_bot_prod, top_prod_top]
Theorem: Multiset.powersetCard_le_powerset
File: Mathlib/Data/Multiset/Powerset.lean

Proof steps:
state_before: α : Type u_1
n : ℕ
s : Multiset α
l : List α
⊢ powersetCard n ⟦l⟧ ≤ powerset ⟦l⟧
state_after: α : Type u_1
n : ℕ
s : Multiset α
l : List α
⊢ List.map ofList (sublistsLen n l) <+~ List.map ofList l.sublists'
tactic: simp only [quot_mk_to_coe, powersetCard_coe, powerset_coe', coe_le]
state_before: α : Type u_1
n : ℕ
s : Multiset α
l : List α
⊢ List.map ofList (sublistsLen n l) <+~ List.map ofList l.sublists'
state_after: no goals
tactic: exact ((sublistsLen_sublist_sublists' _ _).map _).subperm
Theorem: Finset.truncatedSup_infs_of_not_mem
File: Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : DistribLattice α
inst✝² : BoundedOrder α
inst✝¹ : DecidableEq α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a : α
ha : a ∉ lowerClosure ↑s ⊓ lowerClosure ↑t
⊢ a ∉ lowerClosure ↑(s ⊼ t)
state_after: no goals
tactic: rwa [coe_infs, lowerClosure_infs]
Theorem: CategoryTheory.CategoryOfElements.CreatesLimitsAux.liftedCone_pt_snd
File: Mathlib/CategoryTheory/Limits/Elements.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
A : C ⥤ Type w
I : Type u₁
inst✝³ : Category.{v₁, u₁} I
inst✝² : Small.{w, u₁} I
F : I ⥤ A.Elements
inst✝¹ : HasLimitsOfShape I C
inst✝ : PreservesLimitsOfShape I A
i : I
⊢ A.map (limit.π (F ⋙ π A) i) (((Functor.const I).obj ⟨limit (F ⋙ π A), liftedConeElement F⟩).obj i).snd = (F.obj i).snd
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
A : C ⥤ Type w
I : Type u₁
inst✝³ : Category.{v₁, u₁} I
inst✝² : Small.{w, u₁} I
F : I ⥤ A.Elements
inst✝¹ : HasLimitsOfShape I C
inst✝ : PreservesLimitsOfShape I A
i i' : I
f : i ⟶ i'
⊢ ((Functor.const I).obj ⟨limit (F ⋙ π A), liftedConeElement F⟩).map f ≫ (fun i => ⟨limit.π (F ⋙ π A) i, ⋯⟩) i' =
    (fun i => ⟨limit.π (F ⋙ π A) i, ⋯⟩) i ≫ F.map f
state_after: case w
C : Type u
inst✝⁴ : Category.{v, u} C
A : C ⥤ Type w
I : Type u₁
inst✝³ : Category.{v₁, u₁} I
inst✝² : Small.{w, u₁} I
F : I ⥤ A.Elements
inst✝¹ : HasLimitsOfShape I C
inst✝ : PreservesLimitsOfShape I A
i i' : I
f : i ⟶ i'
⊢ ↑(((Functor.const I).obj ⟨limit (F ⋙ π A), liftedConeElement F⟩).map f ≫ (fun i => ⟨limit.π (F ⋙ π A) i, ⋯⟩) i') =
    ↑((fun i => ⟨limit.π (F ⋙ π A) i, ⋯⟩) i ≫ F.map f)
tactic: ext
state_before: case w
C : Type u
inst✝⁴ : Category.{v, u} C
A : C ⥤ Type w
I : Type u₁
inst✝³ : Category.{v₁, u₁} I
inst✝² : Small.{w, u₁} I
F : I ⥤ A.Elements
inst✝¹ : HasLimitsOfShape I C
inst✝ : PreservesLimitsOfShape I A
i i' : I
f : i ⟶ i'
⊢ ↑(((Functor.const I).obj ⟨limit (F ⋙ π A), liftedConeElement F⟩).map f ≫ (fun i => ⟨limit.π (F ⋙ π A) i, ⋯⟩) i') =
    ↑((fun i => ⟨limit.π (F ⋙ π A) i, ⋯⟩) i ≫ F.map f)
state_after: no goals
tactic: simpa using (limit.w _ _).symm
Theorem: vadd_eq_self_of_preimage_zsmul_eq_self
File: Mathlib/Data/Set/Pointwise/Iterate.lean

Proof steps:
state_before: G : Type u_1
inst✝ : CommGroup G
n : ℤ
s : Set G
hs : (fun x => x ^ n) ⁻¹' s = s
g : G
j : ℕ
hg : g ^ n ^ j = 1
⊢ g • s = s
state_after: G : Type u_1
inst✝ : CommGroup G
n : ℤ
s : Set G
hs : (fun x => x ^ n) ⁻¹' s = s
g : G
j : ℕ
hg : g ^ n ^ j = 1
⊢ ∀ {g' : G}, g' ^ n ^ j = 1 → g' • s ⊆ s
tactic: suffices ∀ {g' : G} (_ : g' ^ n ^ j = 1), g' • s ⊆ s by
    refine le_antisymm (this hg) ?_
    conv_lhs => rw [← smul_inv_smul g s]
    replace hg : g⁻¹ ^ n ^ j = 1 := by rw [inv_zpow, hg, inv_one]
    simpa only [le_eq_subset, set_smul_subset_set_smul_iff] using this hg
state_before: G : Type u_1
inst✝ : CommGroup G
n : ℤ
s : Set G
hs : (fun x => x ^ n) ⁻¹' s = s
g : G
j : ℕ
hg : g ^ n ^ j = 1
⊢ ∀ {g' : G}, g' ^ n ^ j = 1 → g' • s ⊆ s
state_after: G : Type u_1
inst✝ : CommGroup G
n : ℤ
s : Set G
hs : (fun x => x ^ n) ⁻¹' s = s
g : G
j : ℕ
hg : g ^ n ^ j = 1
⊢ ∀ {g' : G}, g' ^ n ^ j = 1 → g' • (fun x => x ^ n)^[j] ⁻¹' s ⊆ (fun x => x ^ n)^[j] ⁻¹' s
tactic: rw [(IsFixedPt.preimage_iterate hs j : (zpowGroupHom n)^[j] ⁻¹' s = s).symm]
state_before: G : Type u_1
inst✝ : CommGroup G
n : ℤ
s : Set G
hs : (fun x => x ^ n) ⁻¹' s = s
g : G
j : ℕ
hg : g ^ n ^ j = 1
⊢ ∀ {g' : G}, g' ^ n ^ j = 1 → g' • (fun x => x ^ n)^[j] ⁻¹' s ⊆ (fun x => x ^ n)^[j] ⁻¹' s
state_after: case intro.intro
G : Type u_1
inst✝ : CommGroup G
n : ℤ
s : Set G
hs : (fun x => x ^ n) ⁻¹' s = s
g : G
j : ℕ
hg : g ^ n ^ j = 1
g' : G
hg' : g' ^ n ^ j = 1
y : G
hy : y ∈ (fun x => x ^ n)^[j] ⁻¹' s
⊢ (fun x => g' • x) y ∈ (fun x => x ^ n)^[j] ⁻¹' s
tactic: rintro g' hg' - ⟨y, hy, rfl⟩
state_before: case intro.intro
G : Type u_1
inst✝ : CommGroup G
n : ℤ
s : Set G
hs : (fun x => x ^ n) ⁻¹' s = s
g : G
j : ℕ
hg : g ^ n ^ j = 1
g' : G
hg' : g' ^ n ^ j = 1
y : G
hy : y ∈ (fun x => x ^ n)^[j] ⁻¹' s
⊢ (fun x => g' • x) y ∈ (fun x => x ^ n)^[j] ⁻¹' s
state_after: case intro.intro
G : Type u_1
inst✝ : CommGroup G
n : ℤ
s : Set G
hs : (fun x => x ^ n) ⁻¹' s = s
g : G
j : ℕ
hg : g ^ n ^ j = 1
g' : G
hg' : g' ^ n ^ j = 1
y : G
hy : y ∈ (fun x => x ^ n)^[j] ⁻¹' s
⊢ (⇑(zpowGroupHom n))^[j] (g' * y) ∈ s
tactic: change (zpowGroupHom n)^[j] (g' * y) ∈ s
state_before: case intro.intro
G : Type u_1
inst✝ : CommGroup G
n : ℤ
s : Set G
hs : (fun x => x ^ n) ⁻¹' s = s
g : G
j : ℕ
hg : g ^ n ^ j = 1
g' : G
hg' : g' ^ n ^ j = 1
y : G
hy : y ∈ (fun x => x ^ n)^[j] ⁻¹' s
⊢ (⇑(zpowGroupHom n))^[j] (g' * y) ∈ s
state_after: case intro.intro
G : Type u_1
inst✝ : CommGroup G
n : ℤ
s : Set G
hs : (fun x => x ^ n) ⁻¹' s = s
g : G
j : ℕ
hg : g ^ n ^ j = 1
g' y : G
hy : y ∈ (fun x => x ^ n)^[j] ⁻¹' s
hg' : (⇑(zpowGroupHom n))^[j] g' = 1
⊢ (⇑(zpowGroupHom n))^[j] (g' * y) ∈ s
tactic: replace hg' : (zpowGroupHom n)^[j] g' = 1 := by simpa [zpowGroupHom]
state_before: case intro.intro
G : Type u_1
inst✝ : CommGroup G
n : ℤ
s : Set G
hs : (fun x => x ^ n) ⁻¹' s = s
g : G
j : ℕ
hg : g ^ n ^ j = 1
g' y : G
hy : y ∈ (fun x => x ^ n)^[j] ⁻¹' s
hg' : (⇑(zpowGroupHom n))^[j] g' = 1
⊢ (⇑(zpowGroupHom n))^[j] (g' * y) ∈ s
state_after: no goals
tactic: rwa [iterate_map_mul, hg', one_mul]
Theorem: UniformAddGroup.uniformContinuous_iff_open_ker
File: Mathlib/Topology/Algebra/UniformGroup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁸ : UniformSpace α
inst✝⁷ : Group α
inst✝⁶ : UniformGroup α
hom : Type u_3
inst✝⁵ : UniformSpace β
inst✝⁴ : DiscreteTopology β
inst✝³ : Group β
inst✝² : UniformGroup β
inst✝¹ : FunLike hom α β
inst✝ : MonoidHomClass hom α β
f : hom
⊢ UniformContinuous ⇑f ↔ IsOpen ↑(↑f).ker
state_after: case refine_1
α : Type u_1
β : Type u_2
inst✝⁸ : UniformSpace α
inst✝⁷ : Group α
inst✝⁶ : UniformGroup α
hom : Type u_3
inst✝⁵ : UniformSpace β
inst✝⁴ : DiscreteTopology β
inst✝³ : Group β
inst✝² : UniformGroup β
inst✝¹ : FunLike hom α β
inst✝ : MonoidHomClass hom α β
f : hom
hf : UniformContinuous ⇑f
⊢ IsOpen ↑(↑f).ker

case refine_2
α : Type u_1
β : Type u_2
inst✝⁸ : UniformSpace α
inst✝⁷ : Group α
inst✝⁶ : UniformGroup α
hom : Type u_3
inst✝⁵ : UniformSpace β
inst✝⁴ : DiscreteTopology β
inst✝³ : Group β
inst✝² : UniformGroup β
inst✝¹ : FunLike hom α β
inst✝ : MonoidHomClass hom α β
f : hom
hf : IsOpen ↑(↑f).ker
⊢ UniformContinuous ⇑f
tactic: refine ⟨fun hf => ?_, fun hf => ?_⟩
Theorem: CliffordAlgebra.EquivEven.e0_mul_e0
File: Mathlib/LinearAlgebra/CliffordAlgebra/EvenEquiv.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
⊢ (algebraMap R (CliffordAlgebra (Q' Q))) ((Q' Q) (0, 1)) = -1
state_after: no goals
tactic: simp
Theorem: Polynomial.map_id
File: Mathlib/Algebra/Polynomial/Eval.lean

Proof steps:
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]
inst✝ : Semiring S
f : R →+* S
⊢ map (RingHom.id R) p = p
state_after: no goals
tactic: simp [Polynomial.ext_iff, coeff_map]
Theorem: LieModuleHom.map_top
File: Mathlib/Algebra/Lie/Submodule.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
N : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
f : M →ₗ⁅R,L⁆ N
⊢ LieSubmodule.map f ⊤ = f.range
state_after: case h
R : Type u
L : Type v
M : Type w
N : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
f : M →ₗ⁅R,L⁆ N
m✝ : N
⊢ m✝ ∈ LieSubmodule.map f ⊤ ↔ m✝ ∈ f.range
tactic: ext
state_before: case h
R : Type u
L : Type v
M : Type w
N : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
f : M →ₗ⁅R,L⁆ N
m✝ : N
⊢ m✝ ∈ LieSubmodule.map f ⊤ ↔ m✝ ∈ f.range
state_after: no goals
tactic: simp [LieSubmodule.mem_map]
Theorem: Submodule.LinearDisjoint.of_basis_left
File: Mathlib/LinearAlgebra/LinearDisjoint.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
inst✝ : Algebra R S
M N : Submodule R S
ι : Type u_1
m : Basis ι R ↥M
H : LinearMap.ker (mulLeftMap N ⇑m) = ⊥
⊢ M.LinearDisjoint N
state_after: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
inst✝ : Algebra R S
M N : Submodule R S
ι : Type u_1
m : Basis ι R ↥M
H : LinearMap.ker (mulLeftMap N ⇑m) = ⊥
this : AddCommGroup (ι →₀ ↥N) := Finsupp.instAddCommGroup
⊢ M.LinearDisjoint N
tactic: letI : AddCommGroup (ι →₀ N) := Finsupp.instAddCommGroup
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
inst✝ : Algebra R S
M N : Submodule R S
ι : Type u_1
m : Basis ι R ↥M
H : LinearMap.ker (mulLeftMap N ⇑m) = ⊥
this : AddCommGroup (ι →₀ ↥N) := Finsupp.instAddCommGroup
⊢ M.LinearDisjoint N
state_after: no goals
tactic: exact of_basis_left' M N m (LinearMap.ker_eq_bot.1 H)
Theorem: multiplicity.eq_coe_iff
File: Mathlib/RingTheory/Multiplicity.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
n : ℕ
⊢ multiplicity a b = ↑n ↔ a ^ n ∣ b ∧ ¬a ^ (n + 1) ∣ b
state_after: no goals
tactic: exact
    ⟨fun h =>
      let ⟨h₁, h₂⟩ := eq_some_iff.1 h
      h₂ ▸ ⟨pow_multiplicity_dvd _, is_greatest (by
              rw [PartENat.lt_coe_iff]
              exact ⟨h₁, lt_succ_self _⟩)⟩,
      fun h => eq_some_iff.2 ⟨⟨n, h.2⟩, Eq.symm <| unique' h.1 h.2⟩⟩
Theorem: Matrix.rank_mul_le_right
File: Mathlib/Data/Matrix/Rank.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : StrongRankCondition R
A : Matrix m n R
B : Matrix n o R
⊢ (A * B).rank ≤ B.rank
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : StrongRankCondition R
A : Matrix m n R
B : Matrix n o R
⊢ finrank R ↥(LinearMap.range (A.mulVecLin ∘ₗ B.mulVecLin)) ≤ finrank R ↥(LinearMap.range B.mulVecLin)
tactic: rw [rank, rank, mulVecLin_mul]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : StrongRankCondition R
A : Matrix m n R
B : Matrix n o R
⊢ finrank R ↥(LinearMap.range (A.mulVecLin ∘ₗ B.mulVecLin)) ≤ finrank R ↥(LinearMap.range B.mulVecLin)
state_after: no goals
tactic: exact finrank_le_finrank_of_rank_le_rank (LinearMap.lift_rank_comp_le_right _ _)
    (rank_lt_aleph0 _ _)
Theorem: mul_bounded_of_bounded_of_bounded
File: Mathlib/Topology/Bornology/BoundedOperation.lean

Proof steps:
state_before: R : Type u_1
X : Type u_2
inst✝² : PseudoMetricSpace R
inst✝¹ : Mul R
inst✝ : BoundedMul R
f g : X → R
f_bdd : ∃ C, ∀ (x y : X), dist (f x) (f y) ≤ C
g_bdd : ∃ C, ∀ (x y : X), dist (g x) (g y) ≤ C
⊢ ∃ C, ∀ (x y : X), dist ((f * g) x) ((f * g) y) ≤ C
state_after: case intro
R : Type u_1
X : Type u_2
inst✝² : PseudoMetricSpace R
inst✝¹ : Mul R
inst✝ : BoundedMul R
f g : X → R
f_bdd : ∃ C, ∀ (x y : X), dist (f x) (f y) ≤ C
g_bdd : ∃ C, ∀ (x y : X), dist (g x) (g y) ≤ C
C : ℝ
hC : ∀ ⦃x : R⦄, x ∈ range f * range g → ∀ ⦃y : R⦄, y ∈ range f * range g → dist x y ≤ C
⊢ ∃ C, ∀ (x y : X), dist ((f * g) x) ((f * g) y) ≤ C
tactic: obtain ⟨C, hC⟩ := Metric.isBounded_iff.mp <|
    isBounded_mul (Metric.isBounded_range_iff.mpr f_bdd) (Metric.isBounded_range_iff.mpr g_bdd)
state_before: case intro
R : Type u_1
X : Type u_2
inst✝² : PseudoMetricSpace R
inst✝¹ : Mul R
inst✝ : BoundedMul R
f g : X → R
f_bdd : ∃ C, ∀ (x y : X), dist (f x) (f y) ≤ C
g_bdd : ∃ C, ∀ (x y : X), dist (g x) (g y) ≤ C
C : ℝ
hC : ∀ ⦃x : R⦄, x ∈ range f * range g → ∀ ⦃y : R⦄, y ∈ range f * range g → dist x y ≤ C
⊢ ∃ C, ∀ (x y : X), dist ((f * g) x) ((f * g) y) ≤ C
state_after: case h
R : Type u_1
X : Type u_2
inst✝² : PseudoMetricSpace R
inst✝¹ : Mul R
inst✝ : BoundedMul R
f g : X → R
f_bdd : ∃ C, ∀ (x y : X), dist (f x) (f y) ≤ C
g_bdd : ∃ C, ∀ (x y : X), dist (g x) (g y) ≤ C
C : ℝ
hC : ∀ ⦃x : R⦄, x ∈ range f * range g → ∀ ⦃y : R⦄, y ∈ range f * range g → dist x y ≤ C
⊢ ∀ (x y : X), dist ((f * g) x) ((f * g) y) ≤ C
tactic: use C
state_before: case h
R : Type u_1
X : Type u_2
inst✝² : PseudoMetricSpace R
inst✝¹ : Mul R
inst✝ : BoundedMul R
f g : X → R
f_bdd : ∃ C, ∀ (x y : X), dist (f x) (f y) ≤ C
g_bdd : ∃ C, ∀ (x y : X), dist (g x) (g y) ≤ C
C : ℝ
hC : ∀ ⦃x : R⦄, x ∈ range f * range g → ∀ ⦃y : R⦄, y ∈ range f * range g → dist x y ≤ C
⊢ ∀ (x y : X), dist ((f * g) x) ((f * g) y) ≤ C
state_after: case h
R : Type u_1
X : Type u_2
inst✝² : PseudoMetricSpace R
inst✝¹ : Mul R
inst✝ : BoundedMul R
f g : X → R
f_bdd : ∃ C, ∀ (x y : X), dist (f x) (f y) ≤ C
g_bdd : ∃ C, ∀ (x y : X), dist (g x) (g y) ≤ C
C : ℝ
hC : ∀ ⦃x : R⦄, x ∈ range f * range g → ∀ ⦃y : R⦄, y ∈ range f * range g → dist x y ≤ C
x y : X
⊢ dist ((f * g) x) ((f * g) y) ≤ C
tactic: intro x y
state_before: case h
R : Type u_1
X : Type u_2
inst✝² : PseudoMetricSpace R
inst✝¹ : Mul R
inst✝ : BoundedMul R
f g : X → R
f_bdd : ∃ C, ∀ (x y : X), dist (f x) (f y) ≤ C
g_bdd : ∃ C, ∀ (x y : X), dist (g x) (g y) ≤ C
C : ℝ
hC : ∀ ⦃x : R⦄, x ∈ range f * range g → ∀ ⦃y : R⦄, y ∈ range f * range g → dist x y ≤ C
x y : X
⊢ dist ((f * g) x) ((f * g) y) ≤ C
state_after: no goals
tactic: exact hC (Set.mul_mem_mul (Set.mem_range_self (f := f) x) (Set.mem_range_self (f := g) x))
           (Set.mul_mem_mul (Set.mem_range_self (f := f) y) (Set.mem_range_self (f := g) y))
Theorem: MeasureTheory.isPiSystem_squareCylinders
File: Mathlib/MeasureTheory/Constructions/Cylinders.lean

Proof steps:
state_before: ι : Type u_2
α : ι → Type u_1
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsPiSystem (C i)
hC_univ : ∀ (i : ι), univ ∈ C i
⊢ IsPiSystem (squareCylinders C)
state_after: case intro.intro.intro.intro.intro.intro
ι : Type u_2
α : ι → Type u_1
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsPiSystem (C i)
hC_univ : ∀ (i : ι), univ ∈ C i
s₁ : Finset ι
t₁ : (i : ι) → Set (α i)
h₁ : t₁ ∈ univ.pi C
s₂ : Finset ι
t₂ : (i : ι) → Set (α i)
h₂ : t₂ ∈ univ.pi C
hst_nonempty : ((↑s₁).pi t₁ ∩ (↑s₂).pi t₂).Nonempty
⊢ (↑s₁).pi t₁ ∩ (↑s₂).pi t₂ ∈ squareCylinders C
tactic: rintro S₁ ⟨s₁, t₁, h₁, rfl⟩ S₂ ⟨s₂, t₂, h₂, rfl⟩ hst_nonempty
Theorem: dite_nonpos
File: Mathlib/Order/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝² : One α
p : Prop
inst✝¹ : Decidable p
a : p → α
b : ¬p → α
inst✝ : LE α
ha : ∀ (h : p), a h ≤ 1
hb : ∀ (h : ¬p), b h ≤ 1
⊢ dite p a b ≤ 1
state_after: case isTrue
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝² : One α
p : Prop
inst✝¹ : Decidable p
a : p → α
b : ¬p → α
inst✝ : LE α
ha : ∀ (h : p), a h ≤ 1
hb : ∀ (h : ¬p), b h ≤ 1
h✝ : p
⊢ a h✝ ≤ 1

case isFalse
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝² : One α
p : Prop
inst✝¹ : Decidable p
a : p → α
b : ¬p → α
inst✝ : LE α
ha : ∀ (h : p), a h ≤ 1
hb : ∀ (h : ¬p), b h ≤ 1
h✝ : ¬p
⊢ b h✝ ≤ 1
tactic: split
state_before: case isTrue
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝² : One α
p : Prop
inst✝¹ : Decidable p
a : p → α
b : ¬p → α
inst✝ : LE α
ha : ∀ (h : p), a h ≤ 1
hb : ∀ (h : ¬p), b h ≤ 1
h✝ : p
⊢ a h✝ ≤ 1

case isFalse
ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝² : One α
p : Prop
inst✝¹ : Decidable p
a : p → α
b : ¬p → α
inst✝ : LE α
ha : ∀ (h : p), a h ≤ 1
hb : ∀ (h : ¬p), b h ≤ 1
h✝ : ¬p
⊢ b h✝ ≤ 1
state_after: no goals
tactic: exacts [ha ‹_›, hb ‹_›]
Theorem: Primrec.option_isSome
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
σ : Type u_5
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
o : Option α
⊢ (Option.casesOn (id o) false fun b => true) = o.isSome
state_after: no goals
tactic: cases o <;> rfl
Theorem: map_sub_le_add
File: Mathlib/Algebra/Order/Hom/Basic.lean

Proof steps:
state_before: ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝³ : FunLike F α β
inst✝² : Group α
inst✝¹ : OrderedAddCommMonoid β
inst✝ : GroupSeminormClass F α β
f : F
x y : α
⊢ f (x / y) ≤ f x + f y
state_after: ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝³ : FunLike F α β
inst✝² : Group α
inst✝¹ : OrderedAddCommMonoid β
inst✝ : GroupSeminormClass F α β
f : F
x y : α
⊢ f (x * y⁻¹) ≤ f x + f y⁻¹
tactic: rw [div_eq_mul_inv, ← map_inv_eq_map f y]
state_before: ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝³ : FunLike F α β
inst✝² : Group α
inst✝¹ : OrderedAddCommMonoid β
inst✝ : GroupSeminormClass F α β
f : F
x y : α
⊢ f (x * y⁻¹) ≤ f x + f y⁻¹
state_after: no goals
tactic: exact map_mul_le_add _ _ _