ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Finset.mem_shadow_iterate_iff_exists_card
File: Mathlib/Combinatorics/SetFamily/Shadow.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
⊢ t ∈ ∂ ^[k] 𝒜 ↔ ∃ u, u.card = k ∧ Disjoint t u ∧ t ∪ u ∈ 𝒜
state_after: case zero
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s : Finset α
a : α
r : ℕ
t : Finset α
⊢ t ∈ ∂ ^[0] 𝒜 ↔ ∃ u, u.card = 0 ∧ Disjoint t u ∧ t ∪ u ∈ 𝒜

case succ
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s : Finset α
a : α
r k : ℕ
ih : ∀ {t : Finset α}, t ∈ ∂ ^[k] 𝒜 ↔ ∃ u, u.card = k ∧ Disjoint t u ∧ t ∪ u ∈ 𝒜
t : Finset α
⊢ t ∈ ∂ ^[k + 1] 𝒜 ↔ ∃ u, u.card = k + 1 ∧ Disjoint t u ∧ t ∪ u ∈ 𝒜
tactic: induction' k with k ih generalizing t
state_before: case succ
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s : Finset α
a : α
r k : ℕ
ih : ∀ {t : Finset α}, t ∈ ∂ ^[k] 𝒜 ↔ ∃ u, u.card = k ∧ Disjoint t u ∧ t ∪ u ∈ 𝒜
t : Finset α
⊢ t ∈ ∂ ^[k + 1] 𝒜 ↔ ∃ u, u.card = k + 1 ∧ Disjoint t u ∧ t ∪ u ∈ 𝒜
state_after: no goals
tactic: set_option tactic.skipAssignedInstances false in
  simp only [mem_shadow_iff_insert_mem, ih, Function.iterate_succ_apply', card_eq_succ]
  aesop
Theorem: Finset.sum_Ioc_succ_top
File: Mathlib/Algebra/BigOperators/Intervals.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
inst✝ : CommMonoid M
s₂ s₁ s : Finset α
a✝ : α
g f✝ : α → M
a b : ℕ
hab : a ≤ b
f : ℕ → M
⊢ ∏ k ∈ Ioc a (b + 1), f k = (∏ k ∈ Ioc a b, f k) * f (b + 1)
state_after: no goals
tactic: rw [← prod_Ioc_consecutive _ hab (Nat.le_succ b), Nat.Ioc_succ_singleton, prod_singleton]
Theorem: WeierstrassCurve.baseChange_ψ₂
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

Proof steps:
state_before: R : Type r
S : Type s
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing S
W : WeierstrassCurve R
inst✝⁸ : Algebra R S
A : Type u
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : Algebra S A
inst✝⁴ : IsScalarTower R S A
B : Type v
inst✝³ : CommRing B
inst✝² : Algebra R B
inst✝¹ : Algebra S B
inst✝ : IsScalarTower R S B
f : A →ₐ[S] B
⊢ (W.baseChange B).ψ₂ = Polynomial.map (mapRingHom ↑f) (W.baseChange A).ψ₂
state_after: no goals
tactic: rw [← map_ψ₂, map_baseChange]
Theorem: UniformSpace.Completion.continuous_mul
File: Mathlib/Topology/Algebra/UniformRing.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : Ring α
inst✝² : UniformSpace α
inst✝¹ : TopologicalRing α
inst✝ : UniformAddGroup α
⊢ Continuous fun p => p.1 * p.2
state_after: α : Type u_1
inst✝³ : Ring α
inst✝² : UniformSpace α
inst✝¹ : TopologicalRing α
inst✝ : UniformAddGroup α
m : α →+ α →+ Completion α := AddMonoidHom.mul.compr₂ toCompl
⊢ Continuous fun p => p.1 * p.2
tactic: let m := (AddMonoidHom.mul : α →+ α →+ α).compr₂ toCompl
state_before: α : Type u_1
inst✝³ : Ring α
inst✝² : UniformSpace α
inst✝¹ : TopologicalRing α
inst✝ : UniformAddGroup α
m : α →+ α →+ Completion α := AddMonoidHom.mul.compr₂ toCompl
⊢ Continuous fun p => p.1 * p.2
state_after: α : Type u_1
inst✝³ : Ring α
inst✝² : UniformSpace α
inst✝¹ : TopologicalRing α
inst✝ : UniformAddGroup α
m : α →+ α →+ Completion α := AddMonoidHom.mul.compr₂ toCompl
this : Continuous fun p => (m p.1) p.2
⊢ Continuous fun p => p.1 * p.2
tactic: have : Continuous fun p : α × α => m p.1 p.2 := by
    apply (continuous_coe α).comp _
    simp only [AddMonoidHom.coe_mul, AddMonoidHom.coe_mulLeft]
    exact _root_.continuous_mul
state_before: α : Type u_1
inst✝³ : Ring α
inst✝² : UniformSpace α
inst✝¹ : TopologicalRing α
inst✝ : UniformAddGroup α
m : α →+ α →+ Completion α := AddMonoidHom.mul.compr₂ toCompl
this : Continuous fun p => (m p.1) p.2
⊢ Continuous fun p => p.1 * p.2
state_after: α : Type u_1
inst✝³ : Ring α
inst✝² : UniformSpace α
inst✝¹ : TopologicalRing α
inst✝ : UniformAddGroup α
m : α →+ α →+ Completion α := AddMonoidHom.mul.compr₂ toCompl
this : Continuous fun p => (m p.1) p.2
di : DenseInducing ⇑toCompl
⊢ Continuous fun p => p.1 * p.2
tactic: have di : DenseInducing (toCompl : α → Completion α) := denseInducing_coe
state_before: α : Type u_1
inst✝³ : Ring α
inst✝² : UniformSpace α
inst✝¹ : TopologicalRing α
inst✝ : UniformAddGroup α
m : α →+ α →+ Completion α := AddMonoidHom.mul.compr₂ toCompl
this : Continuous fun p => (m p.1) p.2
di : DenseInducing ⇑toCompl
⊢ Continuous fun p => p.1 * p.2
state_after: no goals
tactic: convert di.extend_Z_bilin di this
Theorem: OnePoint.isClosed_infty
File: Mathlib/Topology/Compactification/OnePoint.lean

Proof steps:
state_before: X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
⊢ IsClosed {∞}
state_after: X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
⊢ IsOpen (range some)
tactic: rw [← compl_range_coe, isClosed_compl_iff]
state_before: X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
⊢ IsOpen (range some)
state_after: no goals
tactic: exact isOpen_range_coe
Theorem: Rel.interedges_biUnion
File: Mathlib/Combinatorics/SimpleGraph/Density.lean

Proof steps:
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝³ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝² : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
s : Finset ι
t : Finset κ
f : ι → Finset α
g : κ → Finset β
⊢ interedges r (s.biUnion f) (t.biUnion g) = (s ×ˢ t).biUnion fun ab => interedges r (f ab.1) (g ab.2)
state_after: no goals
tactic: simp_rw [product_biUnion, interedges_biUnion_left, interedges_biUnion_right]
Theorem: MeasureTheory.Measure.integral_comp_inv_mul_left
File: Mathlib/MeasureTheory/Measure/Haar/NormedSpace.lean

Proof steps:
state_before: E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : MeasurableSpace E
inst✝⁴ : BorelSpace E
inst✝³ : FiniteDimensional ℝ E
μ : Measure E
inst✝² : μ.IsAddHaarMeasure
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
s : Set E
g : ℝ → F
a : ℝ
⊢ ∫ (x : ℝ), g (a⁻¹ * x) = |a| • ∫ (y : ℝ), g y
state_after: no goals
tactic: simp_rw [← smul_eq_mul, Measure.integral_comp_inv_smul, FiniteDimensional.finrank_self, pow_one]
Theorem: wbtw_rotate_iff
File: Mathlib/Analysis/Convex/Between.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : OrderedRing R
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module R V
inst✝⁴ : AddTorsor V P
inst✝³ : AddCommGroup V'
inst✝² : Module R V'
inst✝¹ : AddTorsor V' P'
inst✝ : NoZeroSMulDivisors R V
x y z : P
⊢ Wbtw R x y z ∧ Wbtw R z x y ↔ x = y
state_after: no goals
tactic: rw [wbtw_comm, wbtw_swap_right_iff, eq_comm]
Theorem: TopologicalSpace.Compacts.coe_finset_sup
File: Mathlib/Topology/Sets/Compacts.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
ι : Type u_4
s : Finset ι
f : ι → Compacts α
⊢ ↑(s.sup f) = s.sup fun i => ↑(f i)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
ι : Type u_4
s✝ : Finset ι
f : ι → Compacts α
a : ι
s : Finset ι
x✝ : a ∉ s
h : ↑(s.sup f) = s.sup fun i => ↑(f i)
⊢ ↑((Finset.cons a s x✝).sup f) = (Finset.cons a s x✝).sup fun i => ↑(f i)
tactic: refine Finset.cons_induction_on s rfl fun a s _ h => ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
ι : Type u_4
s✝ : Finset ι
f : ι → Compacts α
a : ι
s : Finset ι
x✝ : a ∉ s
h : ↑(s.sup f) = s.sup fun i => ↑(f i)
⊢ ↑((Finset.cons a s x✝).sup f) = (Finset.cons a s x✝).sup fun i => ↑(f i)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
ι : Type u_4
s✝ : Finset ι
f : ι → Compacts α
a : ι
s : Finset ι
x✝ : a ∉ s
h : ↑(s.sup f) = s.sup fun i => ↑(f i)
⊢ ↑(f a) ∪ ↑(s.sup f) = ↑(f a) ∪ s.sup fun i => ↑(f i)
tactic: simp_rw [Finset.sup_cons, coe_sup, sup_eq_union]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
ι : Type u_4
s✝ : Finset ι
f : ι → Compacts α
a : ι
s : Finset ι
x✝ : a ∉ s
h : ↑(s.sup f) = s.sup fun i => ↑(f i)
⊢ ↑(f a) ∪ ↑(s.sup f) = ↑(f a) ∪ s.sup fun i => ↑(f i)
state_after: no goals
tactic: congr
Theorem: HasFDerivWithinAt.mapsTo_tangent_cone
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.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
f : E → F
s : Set E
f' : E →L[𝕜] F
x : E
h : HasFDerivWithinAt f f' s x
⊢ MapsTo (⇑f') (tangentConeAt 𝕜 s x) (tangentConeAt 𝕜 (f '' s) (f x))
state_after: case intro.intro.intro.intro
𝕜 : 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
f : E → F
s : Set E
f' : E →L[𝕜] F
x : E
h : HasFDerivWithinAt f f' s x
v : E
c : ℕ → 𝕜
d : ℕ → E
dtop : ∀ᶠ (n : ℕ) in atTop, x + d n ∈ s
clim : Tendsto (fun n => ‖c n‖) atTop atTop
cdlim : Tendsto (fun n => c n • d n) atTop (𝓝 v)
⊢ f' v ∈ tangentConeAt 𝕜 (f '' s) (f x)
tactic: rintro v ⟨c, d, dtop, clim, cdlim⟩
state_before: case intro.intro.intro.intro
𝕜 : 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
f : E → F
s : Set E
f' : E →L[𝕜] F
x : E
h : HasFDerivWithinAt f f' s x
v : E
c : ℕ → 𝕜
d : ℕ → E
dtop : ∀ᶠ (n : ℕ) in atTop, x + d n ∈ s
clim : Tendsto (fun n => ‖c n‖) atTop atTop
cdlim : Tendsto (fun n => c n • d n) atTop (𝓝 v)
⊢ f' v ∈ tangentConeAt 𝕜 (f '' s) (f x)
state_after: case intro.intro.intro.intro
𝕜 : 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
f : E → F
s : Set E
f' : E →L[𝕜] F
x : E
h : HasFDerivWithinAt f f' s x
v : E
c : ℕ → 𝕜
d : ℕ → E
dtop : ∀ᶠ (n : ℕ) in atTop, x + d n ∈ s
clim : Tendsto (fun n => ‖c n‖) atTop atTop
cdlim : Tendsto (fun n => c n • d n) atTop (𝓝 v)
⊢ {x_1 | (fun n => x + d n ∈ s) x_1} ⊆ {x_1 | (fun n => f x + (fun n => f (x + d n) - f x) n ∈ f '' s) x_1}
tactic: refine
    ⟨c, fun n => f (x + d n) - f x, mem_of_superset dtop ?_, clim, h.lim atTop dtop clim cdlim⟩
state_before: case intro.intro.intro.intro
𝕜 : 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
f : E → F
s : Set E
f' : E →L[𝕜] F
x : E
h : HasFDerivWithinAt f f' s x
v : E
c : ℕ → 𝕜
d : ℕ → E
dtop : ∀ᶠ (n : ℕ) in atTop, x + d n ∈ s
clim : Tendsto (fun n => ‖c n‖) atTop atTop
cdlim : Tendsto (fun n => c n • d n) atTop (𝓝 v)
⊢ {x_1 | (fun n => x + d n ∈ s) x_1} ⊆ {x_1 | (fun n => f x + (fun n => f (x + d n) - f x) n ∈ f '' s) x_1}
state_after: no goals
tactic: simp (config := { contextual := true }) [-mem_image, mem_image_of_mem]
Theorem: List.nthLe_cons
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
a : α
n : ℕ
hl : n < (a :: l).length
⊢ (a :: l).nthLe n hl = if hn : n = 0 then a else l.nthLe (n - 1) ⋯
state_after: case pos
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
a : α
n : ℕ
hl : n < (a :: l).length
h : n = 0
⊢ (a :: l).nthLe n hl = a

case neg
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
a : α
n : ℕ
hl : n < (a :: l).length
h : ¬n = 0
⊢ (a :: l).nthLe n hl = l.nthLe (n - 1) ⋯
tactic: split_ifs with h
state_before: case neg
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
a : α
n : ℕ
hl : n < (a :: l).length
h : ¬n = 0
⊢ (a :: l).nthLe n hl = l.nthLe (n - 1) ⋯
state_after: case neg.nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
n : ℕ
h : ¬n = 0
hl : n < [a].length
⊢ [a].nthLe n hl = [].nthLe (n - 1) ⋯

case neg.cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
n : ℕ
h : ¬n = 0
head✝ : α
tail✝ : List α
hl : n < (a :: head✝ :: tail✝).length
⊢ (a :: head✝ :: tail✝).nthLe n hl = (head✝ :: tail✝).nthLe (n - 1) ⋯
tactic: cases l
state_before: case neg.cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
n : ℕ
h : ¬n = 0
head✝ : α
tail✝ : List α
hl : n < (a :: head✝ :: tail✝).length
⊢ (a :: head✝ :: tail✝).nthLe n hl = (head✝ :: tail✝).nthLe (n - 1) ⋯
state_after: case neg.cons.zero
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a head✝ : α
tail✝ : List α
h : ¬0 = 0
hl : 0 < (a :: head✝ :: tail✝).length
⊢ (a :: head✝ :: tail✝).nthLe 0 hl = (head✝ :: tail✝).nthLe (0 - 1) ⋯

case neg.cons.succ
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a head✝ : α
tail✝ : List α
n✝ : ℕ
h : ¬n✝ + 1 = 0
hl : n✝ + 1 < (a :: head✝ :: tail✝).length
⊢ (a :: head✝ :: tail✝).nthLe (n✝ + 1) hl = (head✝ :: tail✝).nthLe (n✝ + 1 - 1) ⋯
tactic: cases n
state_before: case neg.cons.succ
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a head✝ : α
tail✝ : List α
n✝ : ℕ
h : ¬n✝ + 1 = 0
hl : n✝ + 1 < (a :: head✝ :: tail✝).length
⊢ (a :: head✝ :: tail✝).nthLe (n✝ + 1) hl = (head✝ :: tail✝).nthLe (n✝ + 1 - 1) ⋯
state_after: no goals
tactic: rfl
Theorem: SeminormedCommGroup.mem_closure_iff
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝³ : SeminormedGroup E
inst✝² : SeminormedGroup F
inst✝¹ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : FunLike 𝓕 E F
⊢ a ∈ closure s ↔ ∀ (ε : ℝ), 0 < ε → ∃ b ∈ s, ‖a / b‖ < ε
state_after: no goals
tactic: simp [Metric.mem_closure_iff, dist_eq_norm_div]
Theorem: MeasureTheory.norm_setToFun_le'
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f g : α → E
hT : DominatedFinMeasAdditive μ T C
hf : Integrable f μ
⊢ ‖setToFun μ T hT f‖ ≤ max C 0 * ‖Integrable.toL1 f hf‖
state_after: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f g : α → E
hT : DominatedFinMeasAdditive μ T C
hf : Integrable f μ
⊢ ‖(L1.setToL1 hT) (Integrable.toL1 f hf)‖ ≤ max C 0 * ‖Integrable.toL1 f hf‖
tactic: rw [setToFun_eq hT hf]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f g : α → E
hT : DominatedFinMeasAdditive μ T C
hf : Integrable f μ
⊢ ‖(L1.setToL1 hT) (Integrable.toL1 f hf)‖ ≤ max C 0 * ‖Integrable.toL1 f hf‖
state_after: no goals
tactic: exact L1.norm_setToL1_le_mul_norm' hT _
Theorem: LTSeries.comap_length
File: Mathlib/Order/RelSeries.lean

Proof steps:
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
inst✝¹ : Preorder α
inst✝ : Preorder β
p : LTSeries β
f : α → β
comap : ∀ ⦃x y : α⦄, f x < f y → x < y
surjective : Function.Surjective f
i j : Fin (p.length + 1)
h : i < j
⊢ f ((fun i => ⋯.choose) i) < f ((fun i => ⋯.choose) j)
state_after: no goals
tactic: simpa only [(surjective _).choose_spec] using p.strictMono h
Theorem: WeierstrassCurve.Affine.Point.toClass_eq_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
W✝ : Affine R
f : R →+* S
F : Type u
inst✝ : Field F
W : Affine F
P : W.Point
⊢ toClass P = 0 ↔ P = 0
state_after: case mp
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
W✝ : Affine R
f : R →+* S
F : Type u
inst✝ : Field F
W : Affine F
P : W.Point
⊢ toClass P = 0 → P = 0

case mpr
R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : CommRing S
W✝ : Affine R
f : R →+* S
F : Type u
inst✝ : Field F
W : Affine F
P : W.Point
⊢ P = 0 → toClass P = 0
tactic: constructor
Theorem: AlternatingMap.map_update_self
File: Mathlib/LinearAlgebra/Alternating/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹⁵ : Semiring R
M : Type u_2
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : Module R M
N : Type u_3
inst✝¹² : AddCommMonoid N
inst✝¹¹ : Module R N
P : Type u_4
inst✝¹⁰ : AddCommMonoid P
inst✝⁹ : Module R P
M' : Type u_5
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
N' : Type u_6
inst✝⁶ : AddCommGroup N'
inst✝⁵ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
M₂ : Type u_10
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₂
M₃ : Type u_11
inst✝² : AddCommMonoid M₃
inst✝¹ : Module R M₃
f f' : M [⋀^ι]→ₗ[R] N
g g₂ : M [⋀^ι]→ₗ[R] N'
g' : M' [⋀^ι]→ₗ[R] N'
v : ι → M
v' : ι → M'
inst✝ : DecidableEq ι
i j : ι
hij : i ≠ j
⊢ update v i (v j) i = update v i (v j) j
state_after: no goals
tactic: rw [Function.update_same, Function.update_noteq hij.symm]
Theorem: LinearMap.BilinForm.sum_apply
File: Mathlib/LinearAlgebra/BilinearForm/Hom.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝⁸ : CommSemiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝⁵ : CommRing R₁
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
w✝ : M
α : Type u_7
t : Finset α
B : α → BilinForm R M
v w : M
⊢ ((∑ i ∈ t, B i) v) w = ∑ i ∈ t, ((B i) v) w
state_after: no goals
tactic: simp only [coeFn_sum, Finset.sum_apply]
Theorem: CompleteLattice.Independent.subtype_ne_bot_le_finrank
File: Mathlib/LinearAlgebra/Dimension/Finite.lean

Proof steps:
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝¹⁰ : Ring R
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup M'
inst✝⁷ : AddCommGroup M₁
inst✝⁶ : Module R M
inst✝⁵ : Module R M'
inst✝⁴ : Module R M₁
inst✝³ : StrongRankCondition R
inst✝² : Module.Finite R M
inst✝¹ : NoZeroSMulDivisors R M
p : ι → Submodule R M
hp : Independent p
inst✝ : Fintype { i // p i ≠ ⊥ }
⊢ Fintype.card { i // p i ≠ ⊥ } ≤ finrank R M
state_after: no goals
tactic: simpa using hp.subtype_ne_bot_le_finrank_aux
Theorem: Filter.lift'_iInf_of_map_univ
File: Mathlib/Order/Filter/Lift.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f✝ f₁ f₂ : Filter α
h h₁ h₂ : Set α → Set β
f : ι → Filter α
g : Set α → Set β
hg : ∀ {s t : Set α}, g (s ∩ t) = g s ∩ g t
hg' : g univ = univ
s t : Set α
⊢ (𝓟 ∘ g) (s ∩ t) = (𝓟 ∘ g) s ⊓ (𝓟 ∘ g) t
state_after: no goals
tactic: simp only [inf_principal, comp, hg]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f✝ f₁ f₂ : Filter α
h h₁ h₂ : Set α → Set β
f : ι → Filter α
g : Set α → Set β
hg : ∀ {s t : Set α}, g (s ∩ t) = g s ∩ g t
hg' : g univ = univ
⊢ (𝓟 ∘ g) univ = ⊤
state_after: no goals
tactic: rw [Function.comp_apply, hg', principal_univ]
Theorem: CochainComplex.shiftShortComplexFunctorIso_add'_hom_app
File: Mathlib/Algebra/Homology/HomotopyCategory/ShiftSequence.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.84737, u_1} C
inst✝ : Preadditive C
n m mn : ℤ
hmn : m + n = mn
a a' a'' : ℤ
ha' : n + a = a'
ha'' : m + a' = a''
K : CochainComplex C ℤ
⊢ mn + a = a''
state_after: no goals
tactic: rw [← ha'', ← ha', ← add_assoc, hmn]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
n m mn : ℤ
hmn : m + n = mn
a a' a'' : ℤ
ha' : n + a = a'
ha'' : m + a' = a''
K : CochainComplex C ℤ
⊢ (shiftShortComplexFunctorIso C mn a a'' ⋯).hom.app K =
    (shortComplexFunctor C (up ℤ) a).map ((CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) m n mn hmn).hom.app K) ≫
      (shiftShortComplexFunctorIso C n a a' ha').hom.app ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) m).obj K) ≫
        (shiftShortComplexFunctorIso C m a' a'' ha'').hom.app K
state_after: no goals
tactic: ext <;> dsimp <;> simp only [← hmn, Int.negOnePow_add, shiftFunctorAdd'_hom_app_f',
    XIsoOfEq_shift, Linear.comp_units_smul, Linear.units_smul_comp,
    XIsoOfEq_hom_comp_XIsoOfEq_hom, smul_smul]
Theorem: Ideal.Polynomial.isMaximal_comap_C_of_isJacobson'
File: Mathlib/RingTheory/Jacobson.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P✝ : Ideal R[X]
hP✝ : P✝.IsMaximal
P : Ideal R[X]
hP : P.IsMaximal
⊢ (comap C P).IsMaximal
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P✝ : Ideal R[X]
hP✝ : P✝.IsMaximal
P : Ideal R[X]
hP this : P.IsMaximal
⊢ (comap C P).IsMaximal
tactic: haveI := hP
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsJacobson R
P✝ : Ideal R[X]
hP✝ : P✝.IsMaximal
P : Ideal R[X]
hP this : P.IsMaximal
⊢ (comap C P).IsMaximal
state_after: no goals
tactic: exact isMaximal_comap_C_of_isJacobson P
Theorem: frontier_lt_subset_eq
File: Mathlib/Topology/Order/OrderClosed.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderClosedTopology α
f g : β → α
inst✝ : TopologicalSpace β
hf : Continuous f
hg : Continuous g
⊢ frontier {b | f b < g b} ⊆ {b | f b = g b}
state_after: no goals
tactic: simpa only [← not_lt, ← compl_setOf, frontier_compl, eq_comm] using frontier_le_subset_eq hg hf
Theorem: CategoryTheory.Limits.Concrete.cokernel_funext
File: Mathlib/CategoryTheory/Limits/Shapes/ConcreteCategory.lean

Proof steps:
state_before: C✝ : Type u
inst✝⁴ : Category.{v, u} C✝
C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroMorphisms C
inst✝¹ : ConcreteCategory C
M N K : C
f : M ⟶ N
inst✝ : HasCokernel f
g h : cokernel f ⟶ K
w : ∀ (n : (forget C).obj N), g ((cokernel.π f) n) = h ((cokernel.π f) n)
⊢ g = h
state_after: case h.w
C✝ : Type u
inst✝⁴ : Category.{v, u} C✝
C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroMorphisms C
inst✝¹ : ConcreteCategory C
M N K : C
f : M ⟶ N
inst✝ : HasCokernel f
g h : cokernel f ⟶ K
w : ∀ (n : (forget C).obj N), g ((cokernel.π f) n) = h ((cokernel.π f) n)
x : (forget C).obj N
⊢ (coequalizer.π f 0 ≫ g) x = (coequalizer.π f 0 ≫ h) x
tactic: ext x
state_before: case h.w
C✝ : Type u
inst✝⁴ : Category.{v, u} C✝
C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroMorphisms C
inst✝¹ : ConcreteCategory C
M N K : C
f : M ⟶ N
inst✝ : HasCokernel f
g h : cokernel f ⟶ K
w : ∀ (n : (forget C).obj N), g ((cokernel.π f) n) = h ((cokernel.π f) n)
x : (forget C).obj N
⊢ (coequalizer.π f 0 ≫ g) x = (coequalizer.π f 0 ≫ h) x
state_after: no goals
tactic: simpa using w x
Theorem: Filter.eventually_iff_seq_eventually
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι✝ : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
ι : Type u_6
l : Filter ι
p : ι → Prop
inst✝ : l.IsCountablyGenerated
⊢ (∀ᶠ (n : ι) in l, p n) ↔ ∀ (x : ℕ → ι), Tendsto x atTop l → ∀ᶠ (n : ℕ) in atTop, p (x n)
state_after: no goals
tactic: simpa using tendsto_iff_seq_tendsto (f := id) (l := 𝓟 {x | p x})