ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: SmoothBumpFunction.eventuallyEq_one
File: Mathlib/Geometry/Manifold/BumpFunction.lean

Proof steps:
state_before: E : Type uE
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : FiniteDimensional ℝ E
H : Type uH
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
c : M
f : SmoothBumpFunction I c
x : M
⊢ dist (↑(extChartAt I c) c) (↑(extChartAt I c) c) < f.rIn
state_after: E : Type uE
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : FiniteDimensional ℝ E
H : Type uH
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
c : M
f : SmoothBumpFunction I c
x : M
⊢ 0 < f.rIn
tactic: rw [dist_self]
state_before: E : Type uE
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : FiniteDimensional ℝ E
H : Type uH
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type uM
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
c : M
f : SmoothBumpFunction I c
x : M
⊢ 0 < f.rIn
state_after: no goals
tactic: exact f.rIn_pos
Theorem: Set.preimage_sub_const_uIcc
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
⊢ (fun x => x - a) ⁻¹' [[b, c]] = [[b + a, c + a]]
state_after: no goals
tactic: simp [sub_eq_add_neg]
Theorem: List.length_split_le
File: Mathlib/Data/List/Sort.lean

Proof steps:
state_before: α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁' l₂' : List α
h : (a :: l).split = (l₁', l₂')
⊢ l₁'.length ≤ (a :: l).length ∧ l₂'.length ≤ (a :: l).length
state_after: case mk
α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁' l₂' : List α
h : (a :: l).split = (l₁', l₂')
l₁ l₂ : List α
e : l.split = (l₁, l₂)
⊢ l₁'.length ≤ (a :: l).length ∧ l₂'.length ≤ (a :: l).length
tactic: cases' e : split l with l₁ l₂
state_before: case mk
α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁' l₂' : List α
h : (a :: l).split = (l₁', l₂')
l₁ l₂ : List α
e : l.split = (l₁, l₂)
⊢ l₁'.length ≤ (a :: l).length ∧ l₂'.length ≤ (a :: l).length
state_after: case mk
α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁' l₂' : List α
h : (a :: l).split = (l₁', l₂')
l₁ l₂ : List α
e : l.split = (l₁, l₂)
fst_eq✝ : a :: l₂ = l₁'
snd_eq✝ : l₁ = l₂'
⊢ l₁'.length ≤ (a :: l).length ∧ l₂'.length ≤ (a :: l).length
tactic: injection (split_cons_of_eq _ e).symm.trans h
state_before: case mk
α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁' l₂' : List α
h : (a :: l).split = (l₁', l₂')
l₁ l₂ : List α
e : l.split = (l₁, l₂)
fst_eq✝ : a :: l₂ = l₁'
snd_eq✝ : l₁ = l₂'
⊢ l₁'.length ≤ (a :: l).length ∧ l₂'.length ≤ (a :: l).length
state_after: case mk
α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁ l₂ : List α
e : l.split = (l₁, l₂)
h : (a :: l).split = (a :: l₂, l₁)
⊢ (a :: l₂).length ≤ (a :: l).length ∧ l₁.length ≤ (a :: l).length
tactic: substs l₁' l₂'
state_before: case mk
α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁ l₂ : List α
e : l.split = (l₁, l₂)
h : (a :: l).split = (a :: l₂, l₁)
⊢ (a :: l₂).length ≤ (a :: l).length ∧ l₁.length ≤ (a :: l).length
state_after: case mk.intro
α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁ l₂ : List α
e : l.split = (l₁, l₂)
h : (a :: l).split = (a :: l₂, l₁)
h₁ : l₁.length ≤ l.length
h₂ : l₂.length ≤ l.length
⊢ (a :: l₂).length ≤ (a :: l).length ∧ l₁.length ≤ (a :: l).length
tactic: cases' length_split_le e with h₁ h₂
state_before: case mk.intro
α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁ l₂ : List α
e : l.split = (l₁, l₂)
h : (a :: l).split = (a :: l₂, l₁)
h₁ : l₁.length ≤ l.length
h₂ : l₂.length ≤ l.length
⊢ (a :: l₂).length ≤ (a :: l).length ∧ l₁.length ≤ (a :: l).length
state_after: no goals
tactic: exact ⟨Nat.succ_le_succ h₂, Nat.le_succ_of_le h₁⟩
Theorem: SemiconjBy.inv_inv_symm_iff
File: Mathlib/Algebra/Group/Semiconj/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝ : DivisionMonoid G
a x y : G
⊢ SemiconjBy a⁻¹ x⁻¹ y⁻¹ ↔ SemiconjBy a y x
state_after: no goals
tactic: simp_rw [SemiconjBy, ← mul_inv_rev, inv_inj, eq_comm]
Theorem: Finset.monotone_iff_forall_le_cons
File: Mathlib/Data/Finset/Interval.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : Preorder β
s t : Finset α
f : Finset α → β
⊢ Monotone f ↔ ∀ (s : Finset α) ⦃a : α⦄ (ha : a ∉ s), f s ≤ f (cons a s ha)
state_after: no goals
tactic: classical simp [monotone_iff_forall_covBy, covBy_iff_exists_cons]
Theorem: Function.Antiperiodic.const_inv_smul₀
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✝³ : AddCommMonoid α
inst✝² : Neg β
inst✝¹ : DivisionSemiring γ
inst✝ : Module γ α
h : Antiperiodic f c
a : γ
ha : a ≠ 0
⊢ Antiperiodic (fun x => f (a⁻¹ • x)) (a • c)
state_after: no goals
tactic: simpa only [inv_inv] using h.const_smul₀ (inv_ne_zero ha)
Theorem: CategoryTheory.Sheaf.isLocallySurjective_iff_epi'
File: Mathlib/CategoryTheory/Sites/EpiMono.lean

Proof steps:
state_before: C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝⁶ : Category.{v', u'} A
inst✝⁵ : ConcreteCategory A
inst✝⁴ : HasFunctorialSurjectiveInjectiveFactorization A
inst✝³ : J.WEqualsLocallyBijective A
inst✝² : HasSheafify J A
inst✝¹ : J.HasSheafCompose (forget A)
inst✝ : Balanced (Sheaf J A)
F G : Sheaf J A
φ : F ⟶ G
⊢ IsLocallySurjective φ ↔ Epi φ
state_after: case mp
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝⁶ : Category.{v', u'} A
inst✝⁵ : ConcreteCategory A
inst✝⁴ : HasFunctorialSurjectiveInjectiveFactorization A
inst✝³ : J.WEqualsLocallyBijective A
inst✝² : HasSheafify J A
inst✝¹ : J.HasSheafCompose (forget A)
inst✝ : Balanced (Sheaf J A)
F G : Sheaf J A
φ : F ⟶ G
⊢ IsLocallySurjective φ → Epi φ

case mpr
C : Type u
inst✝⁷ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝⁶ : Category.{v', u'} A
inst✝⁵ : ConcreteCategory A
inst✝⁴ : HasFunctorialSurjectiveInjectiveFactorization A
inst✝³ : J.WEqualsLocallyBijective A
inst✝² : HasSheafify J A
inst✝¹ : J.HasSheafCompose (forget A)
inst✝ : Balanced (Sheaf J A)
F G : Sheaf J A
φ : F ⟶ G
⊢ Epi φ → IsLocallySurjective φ
tactic: constructor
Theorem: CategoryTheory.Idempotents.toKaroubi_obj_X
File: Mathlib/CategoryTheory/Idempotents/Karoubi.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{?u.17320, u_1} C
X : C
⊢ 𝟙 X ≫ 𝟙 X = 𝟙 X
state_after: no goals
tactic: rw [comp_id]
state_before: C : Type u_1
inst✝ : Category.{?u.17320, u_1} C
X✝ Y✝ : C
f : X✝ ⟶ Y✝
⊢ f = ((fun X => { X := X, p := 𝟙 X, idem := ⋯ }) X✝).p ≫ f ≫ ((fun X => { X := X, p := 𝟙 X, idem := ⋯ }) Y✝).p
state_after: no goals
tactic: simp only [comp_id, id_comp]
Theorem: differentiableWithinAt_inter
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
ht : t ∈ 𝓝 x
⊢ DifferentiableWithinAt 𝕜 f (s ∩ t) x ↔ DifferentiableWithinAt 𝕜 f s x
state_after: no goals
tactic: simp only [DifferentiableWithinAt, hasFDerivWithinAt_inter ht]
Theorem: maximals_eq_minimals
File: Mathlib/Order/Minimal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a b x : α
inst✝ : IsSymm α r
⊢ maximals r s = minimals r s
state_after: no goals
tactic: rw [minimals_of_symm, maximals_of_symm]
Theorem: ContDiffAt.congr_of_eventuallyEq
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : ContDiffAt 𝕜 n f x
hg : f₁ =ᶠ[𝓝 x] f
⊢ f₁ =ᶠ[𝓝[univ] x] f
state_after: no goals
tactic: rwa [nhdsWithin_univ]
Theorem: MeasureTheory.VectorMeasure.of_diff
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M✝ : Type u_3
inst✝⁵ : AddCommMonoid M✝
inst✝⁴ : TopologicalSpace M✝
inst✝³ : T2Space M✝
v✝ : VectorMeasure α M✝
f : ℕ → Set α
M : Type u_4
inst✝² : AddCommGroup M
inst✝¹ : TopologicalSpace M
inst✝ : T2Space M
v : VectorMeasure α M
A B : Set α
hA : MeasurableSet A
hB : MeasurableSet B
h : A ⊆ B
⊢ ↑v (B \ A) = ↑v B - ↑v A
state_after: no goals
tactic: rw [← of_add_of_diff hA hB h, add_sub_cancel_left]
Theorem: List.permutationsAux_cons
File: Mathlib/Data/List/Permutation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
t : α
ts is : List α
⊢ (t :: ts).permutationsAux is =
    foldr (fun y r => (permutationsAux2 t ts r y id).2) (ts.permutationsAux (t :: is)) is.permutations
state_after: α : Type u_1
β : Type u_2
t : α
ts is : List α
⊢ foldr (fun y r => (permutationsAux2 t ts r y id).2)
      (permutationsAux.rec (fun x => [])
        (fun t ts is IH1 IH2 => foldr (fun y r => (permutationsAux2 t ts r y id).2) IH1 (is :: IH2)) ts (t :: is))
      (is ::
        permutationsAux.rec (fun x => [])
          (fun t ts is IH1 IH2 => foldr (fun y r => (permutationsAux2 t ts r y id).2) IH1 (is :: IH2)) is []) =
    foldr (fun y r => (permutationsAux2 t ts r y id).2)
      (permutationsAux.rec (fun x => [])
        (fun t ts is IH1 IH2 => foldr (fun y r => (permutationsAux2 t ts r y id).2) IH1 (is :: IH2)) ts (t :: is))
      is.permutations
tactic: rw [permutationsAux, permutationsAux.rec]
state_before: α : Type u_1
β : Type u_2
t : α
ts is : List α
⊢ foldr (fun y r => (permutationsAux2 t ts r y id).2)
      (permutationsAux.rec (fun x => [])
        (fun t ts is IH1 IH2 => foldr (fun y r => (permutationsAux2 t ts r y id).2) IH1 (is :: IH2)) ts (t :: is))
      (is ::
        permutationsAux.rec (fun x => [])
          (fun t ts is IH1 IH2 => foldr (fun y r => (permutationsAux2 t ts r y id).2) IH1 (is :: IH2)) is []) =
    foldr (fun y r => (permutationsAux2 t ts r y id).2)
      (permutationsAux.rec (fun x => [])
        (fun t ts is IH1 IH2 => foldr (fun y r => (permutationsAux2 t ts r y id).2) IH1 (is :: IH2)) ts (t :: is))
      is.permutations
state_after: no goals
tactic: rfl
Theorem: AddCircle.closedBall_ae_eq_ball
File: Mathlib/MeasureTheory/Group/AddCircle.lean

Proof steps:
state_before: T : ℝ
hT : Fact (0 < T)
x : AddCircle T
ε : ℝ
⊢ closedBall x ε =ᶠ[ae volume] ball x ε
state_after: case inl
T : ℝ
hT : Fact (0 < T)
x : AddCircle T
ε : ℝ
hε : ε ≤ 0
⊢ closedBall x ε =ᶠ[ae volume] ball x ε

case inr
T : ℝ
hT : Fact (0 < T)
x : AddCircle T
ε : ℝ
hε : 0 < ε
⊢ closedBall x ε =ᶠ[ae volume] ball x ε
tactic: rcases le_or_lt ε 0 with hε | hε
Theorem: Filter.map_pi_map_coprodᵢ_le
File: Mathlib/Order/Filter/Pi.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
β : ι → Type u_3
m : (i : ι) → α i → β i
⊢ map (fun k i => m i (k i)) (Filter.coprodᵢ f) ≤ Filter.coprodᵢ fun i => map (m i) (f i)
state_after: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
β : ι → Type u_3
m : (i : ι) → α i → β i
⊢ ∀ (x : Set ((i : ι) → β i)),
    (∀ (i : ι), ∃ t₁, m i ⁻¹' t₁ ∈ f i ∧ eval i ⁻¹' t₁ ⊆ x) →
      ∀ (i : ι), ∃ t₁ ∈ f i, eval i ⁻¹' t₁ ⊆ (fun k i => m i (k i)) ⁻¹' x
tactic: simp only [le_def, mem_map, mem_coprodᵢ_iff]
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
β : ι → Type u_3
m : (i : ι) → α i → β i
⊢ ∀ (x : Set ((i : ι) → β i)),
    (∀ (i : ι), ∃ t₁, m i ⁻¹' t₁ ∈ f i ∧ eval i ⁻¹' t₁ ⊆ x) →
      ∀ (i : ι), ∃ t₁ ∈ f i, eval i ⁻¹' t₁ ⊆ (fun k i => m i (k i)) ⁻¹' x
state_after: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s✝ : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
β : ι → Type u_3
m : (i : ι) → α i → β i
s : Set ((i : ι) → β i)
h : ∀ (i : ι), ∃ t₁, m i ⁻¹' t₁ ∈ f i ∧ eval i ⁻¹' t₁ ⊆ s
i : ι
⊢ ∃ t₁ ∈ f i, eval i ⁻¹' t₁ ⊆ (fun k i => m i (k i)) ⁻¹' s
tactic: intro s h i
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s✝ : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
β : ι → Type u_3
m : (i : ι) → α i → β i
s : Set ((i : ι) → β i)
h : ∀ (i : ι), ∃ t₁, m i ⁻¹' t₁ ∈ f i ∧ eval i ⁻¹' t₁ ⊆ s
i : ι
⊢ ∃ t₁ ∈ f i, eval i ⁻¹' t₁ ⊆ (fun k i => m i (k i)) ⁻¹' s
state_after: case intro.intro
ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s✝ : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
β : ι → Type u_3
m : (i : ι) → α i → β i
s : Set ((i : ι) → β i)
h : ∀ (i : ι), ∃ t₁, m i ⁻¹' t₁ ∈ f i ∧ eval i ⁻¹' t₁ ⊆ s
i : ι
t : Set (β i)
H : m i ⁻¹' t ∈ f i
hH : eval i ⁻¹' t ⊆ s
⊢ ∃ t₁ ∈ f i, eval i ⁻¹' t₁ ⊆ (fun k i => m i (k i)) ⁻¹' s
tactic: obtain ⟨t, H, hH⟩ := h i
state_before: case intro.intro
ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s✝ : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
β : ι → Type u_3
m : (i : ι) → α i → β i
s : Set ((i : ι) → β i)
h : ∀ (i : ι), ∃ t₁, m i ⁻¹' t₁ ∈ f i ∧ eval i ⁻¹' t₁ ⊆ s
i : ι
t : Set (β i)
H : m i ⁻¹' t ∈ f i
hH : eval i ⁻¹' t ⊆ s
⊢ ∃ t₁ ∈ f i, eval i ⁻¹' t₁ ⊆ (fun k i => m i (k i)) ⁻¹' s
state_after: no goals
tactic: exact ⟨{ x : α i | m i x ∈ t }, H, fun x hx => hH hx⟩
Theorem: Submodule.map_comap_eq
File: Mathlib/Algebra/Module/Submodule/Range.lean

Proof steps:
state_before: R : Type u_1
R₂ : Type u_2
R₃ : Type u_3
K : Type u_4
K₂ : Type u_5
M : Type u_6
M₂ : Type u_7
M₃ : Type u_8
V : Type u_9
V₂ : Type u_10
inst✝¹³ : Semiring R
inst✝¹² : Semiring R₂
inst✝¹¹ : Semiring R₃
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁷ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁶ : Module R M
inst✝⁵ : Module R₂ M₂
inst✝⁴ : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝³ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_11
inst✝² : FunLike F M M₂
inst✝¹ : SemilinearMapClass F τ₁₂ M M₂
inst✝ : RingHomSurjective τ₁₂
f : F
q : Submodule R₂ M₂
⊢ range f ⊓ q ≤ map f (comap f q)
state_after: case intro.intro.refl
R : Type u_1
R₂ : Type u_2
R₃ : Type u_3
K : Type u_4
K₂ : Type u_5
M : Type u_6
M₂ : Type u_7
M₃ : Type u_8
V : Type u_9
V₂ : Type u_10
inst✝¹³ : Semiring R
inst✝¹² : Semiring R₂
inst✝¹¹ : Semiring R₃
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁷ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁶ : Module R M
inst✝⁵ : Module R₂ M₂
inst✝⁴ : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝³ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_11
inst✝² : FunLike F M M₂
inst✝¹ : SemilinearMapClass F τ₁₂ M M₂
inst✝ : RingHomSurjective τ₁₂
f : F
q : Submodule R₂ M₂
x : M
hx : f x ∈ ↑q
⊢ f x ∈ map f (comap f q)
tactic: rintro _ ⟨⟨x, _, rfl⟩, hx⟩
state_before: case intro.intro.refl
R : Type u_1
R₂ : Type u_2
R₃ : Type u_3
K : Type u_4
K₂ : Type u_5
M : Type u_6
M₂ : Type u_7
M₃ : Type u_8
V : Type u_9
V₂ : Type u_10
inst✝¹³ : Semiring R
inst✝¹² : Semiring R₂
inst✝¹¹ : Semiring R₃
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁷ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁶ : Module R M
inst✝⁵ : Module R₂ M₂
inst✝⁴ : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝³ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_11
inst✝² : FunLike F M M₂
inst✝¹ : SemilinearMapClass F τ₁₂ M M₂
inst✝ : RingHomSurjective τ₁₂
f : F
q : Submodule R₂ M₂
x : M
hx : f x ∈ ↑q
⊢ f x ∈ map f (comap f q)
state_after: no goals
tactic: exact ⟨x, hx, rfl⟩
Theorem: AddSubmonoid.LocalizationMap.addEquivOfLocalizations_left_neg_apply
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝³ : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝² : CommMonoid N
P : Type u_3
inst✝¹ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
T : Submonoid P
Q : Type u_4
inst✝ : CommMonoid Q
k : N ≃* P
x : N
⊢ (f.mulEquivOfLocalizations (f.ofMulEquivOfLocalizations k)) x = k x
state_after: no goals
tactic: simp
Theorem: compl_sdiff
File: Mathlib/Order/BooleanAlgebra.lean

Proof steps:
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : BooleanAlgebra α
⊢ (x \ y)ᶜ = x ⇨ y
state_after: no goals
tactic: rw [sdiff_eq, himp_eq, compl_inf, compl_compl, sup_comm]
Theorem: Cardinal.beth_strictMono
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: ⊢ StrictMono beth
state_after: a b : Ordinal.{u_1}
⊢ a < b → beth a < beth b
tactic: intro a b
state_before: a b : Ordinal.{u_1}
⊢ a < b → beth a < beth b
state_after: case h
b : Ordinal.{u_1}
IH : ∀ k < b, ∀ ⦃a : Ordinal.{u_1}⦄, a < k → beth a < beth k
a : Ordinal.{u_1}
⊢ a < b → beth a < beth b
tactic: induction' b using Ordinal.induction with b IH generalizing a
state_before: case h
b : Ordinal.{u_1}
IH : ∀ k < b, ∀ ⦃a : Ordinal.{u_1}⦄, a < k → beth a < beth k
a : Ordinal.{u_1}
⊢ a < b → beth a < beth b
state_after: case h
b : Ordinal.{u_1}
IH : ∀ k < b, ∀ ⦃a : Ordinal.{u_1}⦄, a < k → beth a < beth k
a : Ordinal.{u_1}
h : a < b
⊢ beth a < beth b
tactic: intro h
state_before: case h
b : Ordinal.{u_1}
IH : ∀ k < b, ∀ ⦃a : Ordinal.{u_1}⦄, a < k → beth a < beth k
a : Ordinal.{u_1}
h : a < b
⊢ beth a < beth b
state_after: case h.inl
a : Ordinal.{u_1}
IH : ∀ k < 0, ∀ ⦃a : Ordinal.{u_1}⦄, a < k → beth a < beth k
h : a < 0
⊢ beth a < beth 0

case h.inr.inl.intro
a c : Ordinal.{u_1}
IH : ∀ k < succ c, ∀ ⦃a : Ordinal.{u_1}⦄, a < k → beth a < beth k
h : a < succ c
⊢ beth a < beth (succ c)

case h.inr.inr
b : Ordinal.{u_1}
IH : ∀ k < b, ∀ ⦃a : Ordinal.{u_1}⦄, a < k → beth a < beth k
a : Ordinal.{u_1}
h : a < b
hb : b.IsLimit
⊢ beth a < beth b
tactic: rcases zero_or_succ_or_limit b with (rfl | ⟨c, rfl⟩ | hb)
Theorem: AddMonoid.MulEquiv.coprodCongr_symm_apply
File: Mathlib/GroupTheory/Coprod/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
M' : Type u_3
N' : Type u_4
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass M'
inst✝ : MulOneClass N'
e : M ≃* N
e' : M' ≃* N'
⊢ (Coprod.map ↑e.symm ↑e'.symm).comp (Coprod.map ↑e ↑e') = MonoidHom.id (M ∗ M')
state_after: no goals
tactic: ext <;> simp
state_before: M : Type u_1
N : Type u_2
M' : Type u_3
N' : Type u_4
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass M'
inst✝ : MulOneClass N'
e : M ≃* N
e' : M' ≃* N'
⊢ (Coprod.map ↑e ↑e').comp (Coprod.map ↑e.symm ↑e'.symm) = MonoidHom.id (N ∗ N')
state_after: no goals
tactic: ext <;> simp
Theorem: Matrix.vecMul_mulVec
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : NonUnitalCommSemiring α
inst✝¹ : Fintype m
inst✝ : Fintype n
A : Matrix m n α
B : Matrix m o α
x : n → α
⊢ (A *ᵥ x) ᵥ* B = x ᵥ* (Aᵀ * B)
state_after: no goals
tactic: rw [← vecMul_vecMul, vecMul_transpose]
Theorem: EuclideanSpace.norm_eq
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
𝕜✝ : Type u_3
inst✝¹⁰ : _root_.RCLike 𝕜✝
E : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜✝ E
E' : Type u_5
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜✝ E'
F : Type u_6
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type u_7
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
𝕜 : Type u_8
inst✝¹ : _root_.RCLike 𝕜
n : Type u_9
inst✝ : Fintype n
x : EuclideanSpace 𝕜 n
⊢ ‖x‖ = √(∑ i : n, ‖x i‖ ^ 2)
state_after: no goals
tactic: simpa only [Real.coe_sqrt, NNReal.coe_sum] using congr_arg ((↑) : ℝ≥0 → ℝ) x.nnnorm_eq
Theorem: MeasureTheory.average_union_mem_segment
File: Mathlib/MeasureTheory/Integral/Average.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
μ ν : Measure α
s✝ t✝ : Set α
f✝ g f : α → E
s t : Set α
hd : AEDisjoint μ s t
ht : NullMeasurableSet t μ
hsμ : μ s ≠ ⊤
htμ : μ t ≠ ⊤
hfs : IntegrableOn f s μ
hft : IntegrableOn f t μ
⊢ ⨍ (x : α) in s ∪ t, f x ∂μ ∈ [⨍ (x : α) in s, f x ∂μ-[ℝ]⨍ (x : α) in t, f x ∂μ]
state_after: case pos
α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
μ ν : Measure α
s✝ t✝ : Set α
f✝ g f : α → E
s t : Set α
hd : AEDisjoint μ s t
ht : NullMeasurableSet t μ
hsμ : μ s ≠ ⊤
htμ : μ t ≠ ⊤
hfs : IntegrableOn f s μ
hft : IntegrableOn f t μ
hse : μ s = 0
⊢ ⨍ (x : α) in s ∪ t, f x ∂μ ∈ [⨍ (x : α) in s, f x ∂μ-[ℝ]⨍ (x : α) in t, f x ∂μ]

case neg
α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
μ ν : Measure α
s✝ t✝ : Set α
f✝ g f : α → E
s t : Set α
hd : AEDisjoint μ s t
ht : NullMeasurableSet t μ
hsμ : μ s ≠ ⊤
htμ : μ t ≠ ⊤
hfs : IntegrableOn f s μ
hft : IntegrableOn f t μ
hse : ¬μ s = 0
⊢ ⨍ (x : α) in s ∪ t, f x ∂μ ∈ [⨍ (x : α) in s, f x ∂μ-[ℝ]⨍ (x : α) in t, f x ∂μ]
tactic: by_cases hse : μ s = 0
Theorem: LieModule.Weight.ext_iff
File: Mathlib/Algebra/Lie/Weights/Basic.lean

Proof steps:
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ : Weight R L M
⊢ χ₁ = χ₂ ↔ ⇑χ₁ = ⇑χ₂
state_after: no goals
tactic: aesop
Theorem: MeasureTheory.stoppedValue_upperCrossingTime
File: Mathlib/Probability/Martingale/Upcrossing.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
h : upperCrossingTime a b f N (n + 1) ω ≠ N
⊢ b ≤ stoppedValue f (upperCrossingTime a b f N (n + 1)) ω
state_after: case intro.intro
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
h : upperCrossingTime a b f N (n + 1) ω ≠ N
j : ℕ
hj₁ : j ∈ Set.Icc (lowerCrossingTimeAux a f (upperCrossingTime a b f N n ω) N ω) (upperCrossingTime a b f N (n + 1) ω)
hj₂ : f j ω ∈ Set.Ici b
⊢ b ≤ stoppedValue f (upperCrossingTime a b f N (n + 1)) ω
tactic: obtain ⟨j, hj₁, hj₂⟩ := (hitting_le_iff_of_lt _ (lt_of_le_of_ne upperCrossingTime_le h)).1 le_rfl
state_before: case intro.intro
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
h : upperCrossingTime a b f N (n + 1) ω ≠ N
j : ℕ
hj₁ : j ∈ Set.Icc (lowerCrossingTimeAux a f (upperCrossingTime a b f N n ω) N ω) (upperCrossingTime a b f N (n + 1) ω)
hj₂ : f j ω ∈ Set.Ici b
⊢ b ≤ stoppedValue f (upperCrossingTime a b f N (n + 1)) ω
state_after: no goals
tactic: exact stoppedValue_hitting_mem ⟨j, ⟨hj₁.1, le_trans hj₁.2 (hitting_le _)⟩, hj₂⟩