ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: HahnSeries.order_neg
File: Mathlib/RingTheory/HahnSeries/Addition.lean

Proof steps:
state_before: Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : AddGroup R
inst✝ : Zero Γ
f : HahnSeries Γ R
⊢ (-f).order = f.order
state_after: case pos
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : AddGroup R
inst✝ : Zero Γ
f : HahnSeries Γ R
hf : f = 0
⊢ (-f).order = f.order

case neg
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : AddGroup R
inst✝ : Zero Γ
f : HahnSeries Γ R
hf : ¬f = 0
⊢ (-f).order = f.order
tactic: by_cases hf : f = 0
state_before: case neg
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : AddGroup R
inst✝ : Zero Γ
f : HahnSeries Γ R
hf : ¬f = 0
⊢ (-f).order = f.order
state_after: no goals
tactic: simp only [order, support_neg, neg_eq_zero]
Theorem: Matrix.TransvectionStruct.reverse_inv_prod_mul_prod
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

Proof steps:
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
L : List (TransvectionStruct n R)
⊢ (List.map (toMatrix ∘ TransvectionStruct.inv) L.reverse).prod * (List.map toMatrix L).prod = 1
state_after: case nil
n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
⊢ (List.map (toMatrix ∘ TransvectionStruct.inv) [].reverse).prod * (List.map toMatrix []).prod = 1

case cons
n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
t : TransvectionStruct n R
L : List (TransvectionStruct n R)
IH : (List.map (toMatrix ∘ TransvectionStruct.inv) L.reverse).prod * (List.map toMatrix L).prod = 1
⊢ (List.map (toMatrix ∘ TransvectionStruct.inv) (t :: L).reverse).prod * (List.map toMatrix (t :: L)).prod = 1
tactic: induction' L with t L IH
Theorem: Matroid.disjointSigma_indep_iff
File: Mathlib/Data/Matroid/Sum.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
M : ι → Matroid α
h : Pairwise (Disjoint on fun i => (M i).E)
I : Set α
⊢ (Matroid.disjointSigma M h).Indep I ↔ (∀ (i : ι), (M i).Indep (I ∩ (M i).E)) ∧ I ⊆ ⋃ i, (M i).E
state_after: no goals
tactic: simp [Matroid.disjointSigma, (Function.Embedding.sigmaSet_preimage h)]
Theorem: CategoryTheory.Comonad.ForgetCreatesColimits'.coconePoint_A
File: Mathlib/CategoryTheory/Monad/Limits.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D✝ : Type u₂
inst✝¹ : Category.{v₂, u₂} D✝
J : Type u
inst✝ : Category.{v, u} J
T : Comonad C
D : J ⥤ T.Coalgebra
c : Cocone (D ⋙ T.forget)
t : IsColimit c
j : J
⊢ c.ι.app j ≫ t.desc (newCocone D c) ≫ T.ε.app c.pt = c.ι.app j ≫ 𝟙 c.pt
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D✝ : Type u₂
inst✝¹ : Category.{v₂, u₂} D✝
J : Type u
inst✝ : Category.{v, u} J
T : Comonad C
D : J ⥤ T.Coalgebra
c : Cocone (D ⋙ T.forget)
t : IsColimit c
j : J
⊢ (D.obj j).a ≫ T.ε.app (D.obj j).A ≫ c.ι.app j = c.ι.app j
tactic: simp only [Functor.comp_obj, forget_obj, Functor.id_obj, Functor.const_obj_obj,
      IsColimit.fac_assoc, newCocone_ι_app, assoc, NatTrans.naturality, Functor.id_map, comp_id]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D✝ : Type u₂
inst✝¹ : Category.{v₂, u₂} D✝
J : Type u
inst✝ : Category.{v, u} J
T : Comonad C
D : J ⥤ T.Coalgebra
c : Cocone (D ⋙ T.forget)
t : IsColimit c
j : J
⊢ (D.obj j).a ≫ T.ε.app (D.obj j).A ≫ c.ι.app j = c.ι.app j
state_after: no goals
tactic: rw [← Category.assoc, (D.obj j).counit, Category.id_comp]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D✝ : Type u₂
inst✝¹ : Category.{v₂, u₂} D✝
J : Type u
inst✝ : Category.{v, u} J
T : Comonad C
D : J ⥤ T.Coalgebra
c : Cocone (D ⋙ T.forget)
t : IsColimit c
j : J
⊢ c.ι.app j ≫ t.desc (newCocone D c) ≫ T.δ.app c.pt =
    c.ι.app j ≫ t.desc (newCocone D c) ≫ T.map (t.desc (newCocone D c))
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D✝ : Type u₂
inst✝¹ : Category.{v₂, u₂} D✝
J : Type u
inst✝ : Category.{v, u} J
T : Comonad C
D : J ⥤ T.Coalgebra
c : Cocone (D ⋙ T.forget)
t : IsColimit c
j : J
⊢ (D.obj j).a ≫ T.δ.app (D.obj j).A ≫ T.map (T.map (c.ι.app j)) =
    (D.obj j).a ≫ T.map (c.ι.app j) ≫ T.map (t.desc (newCocone D c))
tactic: simp only [Functor.comp_obj, forget_obj, Functor.const_obj_obj, IsColimit.fac_assoc,
      newCocone_ι_app, assoc, NatTrans.naturality, Functor.comp_map]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D✝ : Type u₂
inst✝¹ : Category.{v₂, u₂} D✝
J : Type u
inst✝ : Category.{v, u} J
T : Comonad C
D : J ⥤ T.Coalgebra
c : Cocone (D ⋙ T.forget)
t : IsColimit c
j : J
⊢ (D.obj j).a ≫ T.δ.app (D.obj j).A ≫ T.map (T.map (c.ι.app j)) =
    (D.obj j).a ≫ T.map (c.ι.app j) ≫ T.map (t.desc (newCocone D c))
state_after: no goals
tactic: rw [← Category.assoc, (D.obj j).coassoc, ← Functor.map_comp, t.fac (newCocone D c) j,
      newCocone_ι_app, Functor.map_comp, assoc]
Theorem: MeasureTheory.Integrable.measure_le_lt_top
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f μ
c : ℝ
c_neg : c < 0
⊢ μ {a | f a ≤ c} < ⊤
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f μ
c : ℝ
c_neg : c < 0
⊢ {a | f a ≤ c} ⊆ {x | -c ≤ ‖f x‖}
tactic: refine lt_of_le_of_lt (measure_mono ?_) (hf.measure_norm_ge_lt_top (show 0 < -c by linarith))
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f μ
c : ℝ
c_neg : c < 0
⊢ {a | f a ≤ c} ⊆ {x | -c ≤ ‖f x‖}
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f μ
c : ℝ
c_neg : c < 0
x : α
hx : x ∈ {a | f a ≤ c}
⊢ x ∈ {x | -c ≤ ‖f x‖}
tactic: intro x hx
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f μ
c : ℝ
c_neg : c < 0
x : α
hx : x ∈ {a | f a ≤ c}
⊢ x ∈ {x | -c ≤ ‖f x‖}
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f μ
c : ℝ
c_neg : c < 0
x : α
hx : f x ≤ c
⊢ -c ≤ |f x|
tactic: simp only [Real.norm_eq_abs, Set.mem_setOf_eq] at hx ⊢
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ
hf : Integrable f μ
c : ℝ
c_neg : c < 0
x : α
hx : f x ≤ c
⊢ -c ≤ |f x|
state_after: no goals
tactic: exact (show -c ≤ - f x by linarith).trans (neg_le_abs _)
Theorem: CategoryTheory.Limits.Types.equalizerIso_hom_comp_subtype
File: Mathlib/CategoryTheory/Limits/Shapes/Types.lean

Proof steps:
state_before: X Y Z : Type u
f : X ⟶ Y
g h : Y ⟶ Z
w : f ≫ g = f ≫ h
⊢ (equalizerIso g h).hom ≫ Subtype.val = equalizer.ι g h
state_after: no goals
tactic: rfl
Theorem: gauge_neg
File: Mathlib/Analysis/Convex/Gauge.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
symmetric : ∀ x ∈ s, -x ∈ s
x : E
⊢ gauge s (-x) = gauge s x
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
symmetric : ∀ x ∈ s, -x ∈ s
x : E
this : ∀ (x : E), -x ∈ s ↔ x ∈ s
⊢ gauge s (-x) = gauge s x
tactic: have : ∀ x, -x ∈ s ↔ x ∈ s := fun x => ⟨fun h => by simpa using symmetric _ h, symmetric x⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
symmetric : ∀ x ∈ s, -x ∈ s
x : E
this : ∀ (x : E), -x ∈ s ↔ x ∈ s
⊢ gauge s (-x) = gauge s x
state_after: no goals
tactic: simp_rw [gauge_def', smul_neg, this]
Theorem: Ideal.factors_decreasing
File: Mathlib/RingTheory/Ideal/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
a b : α
inst✝¹ : CommSemiring α
I : Ideal α
inst✝ : IsDomain α
b₁ b₂ : α
h₁ : b₁ ≠ 0
h₂ : ¬IsUnit b₂
h : span {b₁} ≤ span {b₁ * b₂}
⊢ b₁ * b₂ ∣ b₁ * 1
state_after: no goals
tactic: rwa [mul_one, ← Ideal.span_singleton_le_span_singleton]
Theorem: Complex.interior_setOf_le_re
File: Mathlib/Analysis/Complex/ReImTopology.lean

Proof steps:
state_before: a : ℝ
⊢ interior {z | a ≤ z.re} = {z | a < z.re}
state_after: no goals
tactic: simpa only [interior_Ici] using interior_preimage_re (Ici a)
Theorem: IsPrimitiveRoot.totient_le_degree_minpoly
File: Mathlib/RingTheory/RootsOfUnity/Minpoly.lean

Proof steps:
state_before: n : ℕ
K : Type u_1
inst✝² : CommRing K
μ : K
h : IsPrimitiveRoot μ n
inst✝¹ : IsDomain K
inst✝ : CharZero K
⊢ n.totient ≤ (minpoly ℤ μ).natDegree
state_after: no goals
tactic: classical
  let P : ℤ[X] := minpoly ℤ μ
  -- minimal polynomial of `μ`
  let P_K : K[X] := map (Int.castRingHom K) P
  -- minimal polynomial of `μ` sent to `K[X]`
  calc
    n.totient = (primitiveRoots n K).card := h.card_primitiveRoots.symm
    _ ≤ P_K.roots.toFinset.card := Finset.card_le_card (is_roots_of_minpoly h)
    _ ≤ Multiset.card P_K.roots := Multiset.toFinset_card_le _
    _ ≤ P_K.natDegree := card_roots' _
    _ ≤ P.natDegree := natDegree_map_le _ _
Theorem: Batteries.RBNode.All.del
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

Proof steps:
state_before: α : Type u_1
p : α → Prop
cut : α → Ordering
c✝ : RBColor
a✝² : RBNode α
a✝¹ : α
a✝ : RBNode α
hy : p a✝¹
ha : All p a✝²
hb : All p a✝
⊢ All p (del cut (node c✝ a✝² a✝¹ a✝))
state_after: α : Type u_1
p : α → Prop
cut : α → Ordering
c✝ : RBColor
a✝² : RBNode α
a✝¹ : α
a✝ : RBNode α
hy : p a✝¹
ha : All p a✝²
hb : All p a✝
⊢ All p
    (match cut a✝¹ with
    | Ordering.lt =>
      match a✝².isBlack with
      | black => (del cut a✝²).balLeft a✝¹ a✝
      | red => node red (del cut a✝²) a✝¹ a✝
    | Ordering.gt =>
      match a✝.isBlack with
      | black => a✝².balRight a✝¹ (del cut a✝)
      | red => node red a✝² a✝¹ (del cut a✝)
    | Ordering.eq => a✝².append a✝)
tactic: unfold del
state_before: α : Type u_1
p : α → Prop
cut : α → Ordering
c✝ : RBColor
a✝² : RBNode α
a✝¹ : α
a✝ : RBNode α
hy : p a✝¹
ha : All p a✝²
hb : All p a✝
⊢ All p
    (match cut a✝¹ with
    | Ordering.lt =>
      match a✝².isBlack with
      | black => (del cut a✝²).balLeft a✝¹ a✝
      | red => node red (del cut a✝²) a✝¹ a✝
    | Ordering.gt =>
      match a✝.isBlack with
      | black => a✝².balRight a✝¹ (del cut a✝)
      | red => node red a✝² a✝¹ (del cut a✝)
    | Ordering.eq => a✝².append a✝)
state_after: case h_1
α : Type u_1
p : α → Prop
cut : α → Ordering
c✝ : RBColor
a✝² : RBNode α
a✝¹ : α
a✝ : RBNode α
hy : p a✝¹
ha : All p a✝²
hb : All p a✝
x✝ : Ordering
heq✝ : cut a✝¹ = Ordering.lt
⊢ All p
    (match a✝².isBlack with
    | black => (del cut a✝²).balLeft a✝¹ a✝
    | red => node red (del cut a✝²) a✝¹ a✝)

case h_2
α : Type u_1
p : α → Prop
cut : α → Ordering
c✝ : RBColor
a✝² : RBNode α
a✝¹ : α
a✝ : RBNode α
hy : p a✝¹
ha : All p a✝²
hb : All p a✝
x✝ : Ordering
heq✝ : cut a✝¹ = Ordering.gt
⊢ All p
    (match a✝.isBlack with
    | black => a✝².balRight a✝¹ (del cut a✝)
    | red => node red a✝² a✝¹ (del cut a✝))

case h_3
α : Type u_1
p : α → Prop
cut : α → Ordering
c✝ : RBColor
a✝² : RBNode α
a✝¹ : α
a✝ : RBNode α
hy : p a✝¹
ha : All p a✝²
hb : All p a✝
x✝ : Ordering
heq✝ : cut a✝¹ = Ordering.eq
⊢ All p (a✝².append a✝)
tactic: split
Theorem: Metric.comap_dist_right_atTop
File: Mathlib/Topology/MetricSpace/Bounded.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x : α
s t : Set α
r : ℝ
c : α
⊢ (cobounded α).HasBasis (fun x => True) fun i => (fun x => dist x c) ⁻¹' Ici i
state_after: no goals
tactic: simpa only [compl_def, mem_ball, not_lt] using hasBasis_cobounded_compl_ball c
Theorem: Ordinal.lift_pred
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{v}
h : ∃ a, o = succ a
⊢ lift.{u, v} o.pred = (lift.{u, v} o).pred
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o a : Ordinal.{v}
e : o = succ a
⊢ lift.{u, v} o.pred = (lift.{u, v} o).pred
tactic: cases' h with a e
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o a : Ordinal.{v}
e : o = succ a
⊢ lift.{u, v} o.pred = (lift.{u, v} o).pred
state_after: no goals
tactic: simp only [e, pred_succ, lift_succ]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{v}
h : ¬∃ a, o = succ a
⊢ lift.{u, v} o.pred = (lift.{u, v} o).pred
state_after: no goals
tactic: rw [pred_eq_iff_not_succ.2 h, pred_eq_iff_not_succ.2 (mt lift_is_succ.1 h)]
Theorem: zpow_neg
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a✝ b c d a : α
⊢ a ^ (-0) = (a ^ 0)⁻¹
state_after: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a✝ b c d a : α
⊢ a ^ 0 = (a ^ 0)⁻¹
tactic: change a ^ (0 : ℤ) = (a ^ (0 : ℤ))⁻¹
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a✝ b c d a : α
⊢ a ^ 0 = (a ^ 0)⁻¹
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a✝ b c d a : α
n : ℕ
⊢ a ^ (-Int.negSucc n) = (a ^ Int.negSucc n)⁻¹
state_after: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a✝ b c d a : α
n : ℕ
⊢ a ^ (-Int.negSucc n) = a ^ ↑(n + 1)
tactic: rw [zpow_negSucc, inv_inv, ← zpow_natCast]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a✝ b c d a : α
n : ℕ
⊢ a ^ (-Int.negSucc n) = a ^ ↑(n + 1)
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Limits.PullbackCone.equalizer_ext
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/PullbackCone.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
W✝ X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
t : PullbackCone f g
W : C
k l : W ⟶ t.pt
h₀ : k ≫ t.fst = l ≫ t.fst
h₁ : k ≫ t.snd = l ≫ t.snd
⊢ k ≫ t.π.app none = l ≫ t.π.app none
state_after: no goals
tactic: rw [← t.w inl, reassoc_of% h₀]
Theorem: Finset.univ_map_equiv_to_embedding
File: Mathlib/Data/Fintype/Basic.lean

Proof steps:
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
inst✝² : Fintype α✝
s t : Finset α✝
α : Type u_4
β : Type u_5
inst✝¹ : Fintype α
inst✝ : Fintype β
e : α ≃ β
b : β
⊢ e.toEmbedding (e.symm b) = b
state_after: no goals
tactic: simp
Theorem: Matrix.linfty_opNorm_row
File: Mathlib/Analysis/Matrix.lean

Proof steps:
state_before: R : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type u_5
β : Type u_6
ι : Type u_7
inst✝⁴ : Fintype l
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : Unique ι
inst✝ : SeminormedAddCommGroup α
v : n → α
⊢ ↑(∑ i : n, ‖v i‖₊) = ∑ i : n, ‖v i‖
state_after: no goals
tactic: simp [NNReal.coe_sum]
Theorem: DirectedOn.exists_mem_subset_of_finset_subset_biUnion
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
inst✝ : LinearOrder α✝
s✝ : Set α✝
α : Type u_1
ι : Type u_2
f : ι → Set α
c : Set ι
hn : c.Nonempty
hc : DirectedOn (fun i j => f i ⊆ f j) c
s : Finset α
hs : ↑s ⊆ ⋃ i ∈ c, f i
⊢ ∃ i ∈ c, ↑s ⊆ f i
state_after: α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
inst✝ : LinearOrder α✝
s✝ : Set α✝
α : Type u_1
ι : Type u_2
f : ι → Set α
c : Set ι
hn : c.Nonempty
hc : DirectedOn (fun i j => f i ⊆ f j) c
s : Finset α
hs : ↑s ⊆ ⋃ x, f ↑x
⊢ ∃ i ∈ c, ↑s ⊆ f i
tactic: rw [Set.biUnion_eq_iUnion] at hs
state_before: α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
inst✝ : LinearOrder α✝
s✝ : Set α✝
α : Type u_1
ι : Type u_2
f : ι → Set α
c : Set ι
hn : c.Nonempty
hc : DirectedOn (fun i j => f i ⊆ f j) c
s : Finset α
hs : ↑s ⊆ ⋃ x, f ↑x
⊢ ∃ i ∈ c, ↑s ⊆ f i
state_after: α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
inst✝ : LinearOrder α✝
s✝ : Set α✝
α : Type u_1
ι : Type u_2
f : ι → Set α
c : Set ι
hn : c.Nonempty
hc : DirectedOn (fun i j => f i ⊆ f j) c
s : Finset α
hs : ↑s ⊆ ⋃ x, f ↑x
this : Nonempty ↑c
⊢ ∃ i ∈ c, ↑s ⊆ f i
tactic: haveI := hn.coe_sort
state_before: α✝ : Type u
β : Type v
ι✝ : Sort w
γ : Type x
inst✝ : LinearOrder α✝
s✝ : Set α✝
α : Type u_1
ι : Type u_2
f : ι → Set α
c : Set ι
hn : c.Nonempty
hc : DirectedOn (fun i j => f i ⊆ f j) c
s : Finset α
hs : ↑s ⊆ ⋃ x, f ↑x
this : Nonempty ↑c
⊢ ∃ i ∈ c, ↑s ⊆ f i
state_after: no goals
tactic: simpa using (directed_comp.2 hc.directed_val).exists_mem_subset_of_finset_subset_biUnion hs
Theorem: DFinsupp.neLocus_self_sub_left
File: Mathlib/Data/DFinsupp/NeLocus.lean

Proof steps:
state_before: α : Type u_1
N : α → Type u_2
inst✝² : DecidableEq α
inst✝¹ : (a : α) → DecidableEq (N a)
inst✝ : (a : α) → AddGroup (N a)
f f₁ f₂ g g₁ g₂ : Π₀ (a : α), N a
⊢ (f - g).neLocus f = g.support
state_after: no goals
tactic: rw [neLocus_comm, neLocus_self_sub_right]
Theorem: LinearMap.toMatrix₂_basisFun
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
S₁ : Type u_3
R₂ : Type u_4
S₂ : Type u_5
M : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₁' : Type u_9
M₂' : Type u_10
N₂ : Type u_11
n : Type u_12
m : Type u_13
n' : Type u_14
m' : Type u_15
ι : Type u_16
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M₁
inst✝⁸ : Module R M₁
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Module R M₂
inst✝⁵ : AddCommMonoid N₂
inst✝⁴ : Module R N₂
inst✝³ : DecidableEq n
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : Fintype m
b₁ : Basis n R M₁
b₂ : Basis m R M₂
⊢ toMatrix₂ (Pi.basisFun R n) (Pi.basisFun R m) = toMatrix₂' R
state_after: case h.a
R : Type u_1
R₁ : Type u_2
S₁ : Type u_3
R₂ : Type u_4
S₂ : Type u_5
M : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₁' : Type u_9
M₂' : Type u_10
N₂ : Type u_11
n : Type u_12
m : Type u_13
n' : Type u_14
m' : Type u_15
ι : Type u_16
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M₁
inst✝⁸ : Module R M₁
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Module R M₂
inst✝⁵ : AddCommMonoid N₂
inst✝⁴ : Module R N₂
inst✝³ : DecidableEq n
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : Fintype m
b₁ : Basis n R M₁
b₂ : Basis m R M₂
B : (n → R) →ₗ[R] (m → R) →ₗ[R] N₂
i✝ : n
j✝ : m
⊢ (toMatrix₂ (Pi.basisFun R n) (Pi.basisFun R m)) B i✝ j✝ = (toMatrix₂' R) B i✝ j✝
tactic: ext B
state_before: case h.a
R : Type u_1
R₁ : Type u_2
S₁ : Type u_3
R₂ : Type u_4
S₂ : Type u_5
M : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₁' : Type u_9
M₂' : Type u_10
N₂ : Type u_11
n : Type u_12
m : Type u_13
n' : Type u_14
m' : Type u_15
ι : Type u_16
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M₁
inst✝⁸ : Module R M₁
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Module R M₂
inst✝⁵ : AddCommMonoid N₂
inst✝⁴ : Module R N₂
inst✝³ : DecidableEq n
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : Fintype m
b₁ : Basis n R M₁
b₂ : Basis m R M₂
B : (n → R) →ₗ[R] (m → R) →ₗ[R] N₂
i✝ : n
j✝ : m
⊢ (toMatrix₂ (Pi.basisFun R n) (Pi.basisFun R m)) B i✝ j✝ = (toMatrix₂' R) B i✝ j✝
state_after: no goals
tactic: rw [LinearMap.toMatrix₂_apply, LinearMap.toMatrix₂'_apply, Pi.basisFun_apply, Pi.basisFun_apply]
Theorem: Real.ennnorm_eq_ofReal_abs
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✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r✝ r₁ r₂ r : ℝ
⊢ ↑‖r‖₊ = ENNReal.ofReal |r|
state_after: no goals
tactic: rw [← Real.nnnorm_abs r, Real.ennnorm_eq_ofReal (abs_nonneg _)]
Theorem: MeasureTheory.Measure.exists_measure_inter_spanningSets_pos
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
μ✝ ν ν₁ ν₂ : Measure α
s✝ t : Set α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
⊢ (∃ n, 0 < μ (s ∩ spanningSets μ n)) ↔ 0 < μ s
state_after: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
μ✝ ν ν₁ ν₂ : Measure α
s✝ t : Set α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
⊢ (¬∃ n, 0 < μ (s ∩ spanningSets μ n)) ↔ ¬0 < μ s
tactic: rw [← not_iff_not]
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
μ✝ ν ν₁ ν₂ : Measure α
s✝ t : Set α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
⊢ (¬∃ n, 0 < μ (s ∩ spanningSets μ n)) ↔ ¬0 < μ s
state_after: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
μ✝ ν ν₁ ν₂ : Measure α
s✝ t : Set α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
⊢ (∀ (x : ℕ), μ (s ∩ spanningSets μ x) = 0) ↔ μ s = 0
tactic: simp only [not_exists, not_lt, nonpos_iff_eq_zero]
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
μ✝ ν ν₁ ν₂ : Measure α
s✝ t : Set α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
⊢ (∀ (x : ℕ), μ (s ∩ spanningSets μ x) = 0) ↔ μ s = 0
state_after: no goals
tactic: exact forall_measure_inter_spanningSets_eq_zero s
Theorem: PowerSeries.eq_divided_by_X_pow_order_Iff_Unit
File: Mathlib/RingTheory/PowerSeries/Inverse.lean

Proof steps:
state_before: R : Type u_1
k : Type u_2
inst✝ : Field k
f : k⟦X⟧
hf : f ≠ 0
h : f = divided_by_X_pow_order hf
⊢ IsUnit f
state_after: R : Type u_1
k : Type u_2
inst✝ : Field k
f : k⟦X⟧
hf : f ≠ 0
h : f = divided_by_X_pow_order hf
⊢ IsUnit (divided_by_X_pow_order hf)
tactic: rw [h]
state_before: R : Type u_1
k : Type u_2
inst✝ : Field k
f : k⟦X⟧
hf : f ≠ 0
h : f = divided_by_X_pow_order hf
⊢ IsUnit (divided_by_X_pow_order hf)
state_after: no goals
tactic: exact isUnit_divided_by_X_pow_order hf
state_before: R : Type u_1
k : Type u_2
inst✝ : Field k
f : k⟦X⟧
hf : f ≠ 0
h : IsUnit f
⊢ f = divided_by_X_pow_order hf
state_after: R : Type u_1
k : Type u_2
inst✝ : Field k
f : k⟦X⟧
hf : f ≠ 0
h : IsUnit f
this : f.order.get ⋯ = 0
⊢ f = divided_by_X_pow_order hf
tactic: have : f.order.get (order_finite_iff_ne_zero.mpr hf) = 0 := by
      simp only [order_zero_of_unit h, PartENat.get_zero]
state_before: R : Type u_1
k : Type u_2
inst✝ : Field k
f : k⟦X⟧
hf : f ≠ 0
h : IsUnit f
this : f.order.get ⋯ = 0
⊢ f = divided_by_X_pow_order hf
state_after: case h.e'_3
R : Type u_1
k : Type u_2
inst✝ : Field k
f : k⟦X⟧
hf : f ≠ 0
h : IsUnit f
this : f.order.get ⋯ = 0
⊢ divided_by_X_pow_order hf = X ^ f.order.get ⋯ * divided_by_X_pow_order hf
tactic: convert (self_eq_X_pow_order_mul_divided_by_X_pow_order hf).symm
state_before: case h.e'_3
R : Type u_1
k : Type u_2
inst✝ : Field k
f : k⟦X⟧
hf : f ≠ 0
h : IsUnit f
this : f.order.get ⋯ = 0
⊢ divided_by_X_pow_order hf = X ^ f.order.get ⋯ * divided_by_X_pow_order hf
state_after: no goals
tactic: simp only [this, pow_zero, one_mul]
Theorem: SimpleGraph.Walk.reverse_reverse
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : G.Walk u v
⊢ p.reverse.reverse = p
state_after: no goals
tactic: induction p with
  | nil => rfl
  | cons _ _ ih => simp [ih]
Theorem: Fin.foldl_eq_foldl_list
File: .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean

Proof steps:
state_before: α : Type u_1
n : Nat
f : α → Fin n → α
x : α
⊢ foldl n f x = List.foldl f x (list n)
state_after: no goals
tactic: induction n generalizing x with
  | zero => rw [foldl_zero, list_zero, List.foldl_nil]
  | succ n ih => rw [foldl_succ, ih, list_succ, List.foldl_cons, List.foldl_map]