ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Finset.card_le_card_biUnion
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : DecidableEq α
s✝ : Finset α
B : Finset (Finset α)
n : ℕ
s : Finset ι
f : ι → Finset α
hs : (↑s).PairwiseDisjoint f
hf : ∀ i ∈ s, (f i).Nonempty
⊢ s.card ≤ (s.biUnion f).card
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : DecidableEq α
s✝ : Finset α
B : Finset (Finset α)
n : ℕ
s : Finset ι
f : ι → Finset α
hs : (↑s).PairwiseDisjoint f
hf : ∀ i ∈ s, (f i).Nonempty
⊢ ∑ x ∈ s, 1 ≤ ∑ u ∈ s, (f u).card
tactic: rw [card_biUnion hs, card_eq_sum_ones]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : DecidableEq α
s✝ : Finset α
B : Finset (Finset α)
n : ℕ
s : Finset ι
f : ι → Finset α
hs : (↑s).PairwiseDisjoint f
hf : ∀ i ∈ s, (f i).Nonempty
⊢ ∑ x ∈ s, 1 ≤ ∑ u ∈ s, (f u).card
state_after: no goals
tactic: exact sum_le_sum fun i hi ↦ (hf i hi).card_pos
Theorem: isClosed_setOf_map_mul
File: Mathlib/Topology/Algebra/Monoid.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝⁵ : TopologicalSpace X
M₁ : Type u_6
M₂ : Type u_7
inst✝⁴ : TopologicalSpace M₂
inst✝³ : T2Space M₂
inst✝² : Mul M₁
inst✝¹ : Mul M₂
inst✝ : ContinuousMul M₂
⊢ IsClosed {f | ∀ (x y : M₁), f (x * y) = f x * f y}
state_after: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝⁵ : TopologicalSpace X
M₁ : Type u_6
M₂ : Type u_7
inst✝⁴ : TopologicalSpace M₂
inst✝³ : T2Space M₂
inst✝² : Mul M₁
inst✝¹ : Mul M₂
inst✝ : ContinuousMul M₂
⊢ IsClosed (⋂ i, ⋂ i_1, {x | x (i * i_1) = x i * x i_1})
tactic: simp only [setOf_forall]
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝⁵ : TopologicalSpace X
M₁ : Type u_6
M₂ : Type u_7
inst✝⁴ : TopologicalSpace M₂
inst✝³ : T2Space M₂
inst✝² : Mul M₁
inst✝¹ : Mul M₂
inst✝ : ContinuousMul M₂
⊢ IsClosed (⋂ i, ⋂ i_1, {x | x (i * i_1) = x i * x i_1})
state_after: no goals
tactic: exact
    isClosed_iInter fun x =>
      isClosed_iInter fun y =>
        isClosed_eq (continuous_apply _)
          -- Porting note: proof was:
          -- `((continuous_apply _).mul (continuous_apply _))`
          (by continuity)
Theorem: CauSeq.inv_mul_cancel
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : DivisionRing β
abv : β → α
inst✝ : IsAbsoluteValue abv
f : CauSeq β abv
hf : ¬f.LimZero
ε : α
ε0 : ε > 0
K : α
K0 : K > 0
i : ℕ
H : ∀ j ≥ i, K ≤ abv (↑f j)
j : ℕ
ij : j ≥ i
⊢ abv (↑(f.inv hf * f - 1) j) < ε
state_after: no goals
tactic: simpa [(abv_pos abv).1 (lt_of_lt_of_le K0 (H _ ij)), abv_zero abv] using ε0
Theorem: Computation.mem_parallel
File: Mathlib/Data/Seq/Parallel.lean

Proof steps:
state_before: α : Type u
β : Type v
S : WSeq (Computation α)
a : α
H : ∀ (s : Computation α), s ∈ S → s ~> a
c : Computation α
cs : c ∈ S
ac : a ∈ c
⊢ a ∈ parallel S
state_after: α : Type u
β : Type v
S : WSeq (Computation α)
a : α
H : ∀ (s : Computation α), s ∈ S → s ~> a
c : Computation α
cs : c ∈ S
ac : a ∈ c
this : c.Terminates
⊢ a ∈ parallel S
tactic: haveI := terminates_of_mem ac
state_before: α : Type u
β : Type v
S : WSeq (Computation α)
a : α
H : ∀ (s : Computation α), s ∈ S → s ~> a
c : Computation α
cs : c ∈ S
ac : a ∈ c
this : c.Terminates
⊢ a ∈ parallel S
state_after: α : Type u
β : Type v
S : WSeq (Computation α)
a : α
H : ∀ (s : Computation α), s ∈ S → s ~> a
c : Computation α
cs : c ∈ S
ac : a ∈ c
this✝ : c.Terminates
this : (parallel S).Terminates
⊢ a ∈ parallel S
tactic: haveI := terminates_parallel cs
state_before: α : Type u
β : Type v
S : WSeq (Computation α)
a : α
H : ∀ (s : Computation α), s ∈ S → s ~> a
c : Computation α
cs : c ∈ S
ac : a ∈ c
this✝ : c.Terminates
this : (parallel S).Terminates
⊢ a ∈ parallel S
state_after: no goals
tactic: exact mem_of_promises _ (parallel_promises H)
Theorem: Set.indicator_add_eq_right
File: Mathlib/Algebra/Group/Indicator.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s t : Set α
f✝ g✝ : α → M
a : α
f g : α → M
h : Disjoint (mulSupport f) (mulSupport g)
⊢ (mulSupport g).mulIndicator (f * g) = g
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s t : Set α
f✝ g✝ : α → M
a : α
f g : α → M
h : Disjoint (mulSupport f) (mulSupport g)
x : α
hx : x ∈ mulSupport g
⊢ (f * g) x = g x
tactic: refine (mulIndicator_congr fun x hx => ?_).trans mulIndicator_mulSupport
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s t : Set α
f✝ g✝ : α → M
a : α
f g : α → M
h : Disjoint (mulSupport f) (mulSupport g)
x : α
hx : x ∈ mulSupport g
⊢ (f * g) x = g x
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s t : Set α
f✝ g✝ : α → M
a : α
f g : α → M
h : Disjoint (mulSupport f) (mulSupport g)
x : α
hx : x ∈ mulSupport g
this : f x = 1
⊢ (f * g) x = g x
tactic: have : f x = 1 := nmem_mulSupport.1 (disjoint_right.1 h hx)
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s t : Set α
f✝ g✝ : α → M
a : α
f g : α → M
h : Disjoint (mulSupport f) (mulSupport g)
x : α
hx : x ∈ mulSupport g
this : f x = 1
⊢ (f * g) x = g x
state_after: no goals
tactic: rw [Pi.mul_apply, this, one_mul]
Theorem: collinear_empty
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
⊢ Collinear k ∅
state_after: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
⊢ Module.rank k ↥⊥ ≤ 1
tactic: rw [collinear_iff_rank_le_one, vectorSpan_empty]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
⊢ Module.rank k ↥⊥ ≤ 1
state_after: no goals
tactic: simp
Theorem: PadicSeq.norm_eq_of_add_equiv_zero
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
h : f + g ≈ 0
⊢ f.norm = g.norm
state_after: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
h : f + g ≈ 0
this : (f + g - 0).LimZero
⊢ f.norm = g.norm
tactic: have : LimZero (f + g - 0) := h
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
h : f + g ≈ 0
this : (f + g - 0).LimZero
⊢ f.norm = g.norm
state_after: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
h : f + g ≈ 0
this✝ : (f + g - 0).LimZero
this : f ≈ -g
⊢ f.norm = g.norm
tactic: have : f ≈ -g := show LimZero (f - -g) by simpa only [sub_zero, sub_neg_eq_add]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
h : f + g ≈ 0
this✝ : (f + g - 0).LimZero
this : f ≈ -g
⊢ f.norm = g.norm
state_after: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
h : f + g ≈ 0
this✝¹ : (f + g - 0).LimZero
this✝ : f ≈ -g
this : f.norm = (-g).norm
⊢ f.norm = g.norm
tactic: have : f.norm = (-g).norm := norm_equiv this
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
h : f + g ≈ 0
this✝¹ : (f + g - 0).LimZero
this✝ : f ≈ -g
this : f.norm = (-g).norm
⊢ f.norm = g.norm
state_after: no goals
tactic: simpa only [norm_neg] using this
Theorem: MeasureTheory.Measure.haar.chaar_empty
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
⊢ chaar K₀ ⊥ = 0
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
eval : (Compacts G → ℝ) → ℝ := fun f => f ⊥
⊢ chaar K₀ ⊥ = 0
tactic: let eval : (Compacts G → ℝ) → ℝ := fun f => f ⊥
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
eval : (Compacts G → ℝ) → ℝ := fun f => f ⊥
⊢ chaar K₀ ⊥ = 0
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
eval : (Compacts G → ℝ) → ℝ := fun f => f ⊥
this : Continuous eval
⊢ chaar K₀ ⊥ = 0
tactic: have : Continuous eval := continuous_apply ⊥
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
eval : (Compacts G → ℝ) → ℝ := fun f => f ⊥
this : Continuous eval
⊢ chaar K₀ ⊥ = 0
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
eval : (Compacts G → ℝ) → ℝ := fun f => f ⊥
this : Continuous eval
⊢ chaar K₀ ∈ eval ⁻¹' {0}
tactic: show chaar K₀ ∈ eval ⁻¹' {(0 : ℝ)}
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
eval : (Compacts G → ℝ) → ℝ := fun f => f ⊥
this : Continuous eval
⊢ chaar K₀ ∈ eval ⁻¹' {0}
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
eval : (Compacts G → ℝ) → ℝ := fun f => f ⊥
this : Continuous eval
⊢ clPrehaar ↑K₀ ⊤ ⊆ eval ⁻¹' {0}
tactic: apply mem_of_subset_of_mem _ (chaar_mem_clPrehaar K₀ ⊤)
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
eval : (Compacts G → ℝ) → ℝ := fun f => f ⊥
this : Continuous eval
⊢ clPrehaar ↑K₀ ⊤ ⊆ eval ⁻¹' {0}
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
eval : (Compacts G → ℝ) → ℝ := fun f => f ⊥
this : Continuous eval
⊢ closure (prehaar ↑K₀ '' {U | U ⊆ ↑⊤.toOpens ∧ IsOpen U ∧ 1 ∈ U}) ⊆ eval ⁻¹' {0}
tactic: unfold clPrehaar
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
eval : (Compacts G → ℝ) → ℝ := fun f => f ⊥
this : Continuous eval
⊢ closure (prehaar ↑K₀ '' {U | U ⊆ ↑⊤.toOpens ∧ IsOpen U ∧ 1 ∈ U}) ⊆ eval ⁻¹' {0}
state_after: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
eval : (Compacts G → ℝ) → ℝ := fun f => f ⊥
this : Continuous eval
⊢ prehaar ↑K₀ '' {U | U ⊆ ↑⊤.toOpens ∧ IsOpen U ∧ 1 ∈ U} ⊆ eval ⁻¹' {0}

G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
eval : (Compacts G → ℝ) → ℝ := fun f => f ⊥
this : Continuous eval
⊢ IsClosed (eval ⁻¹' {0})
tactic: rw [IsClosed.closure_subset_iff]
Theorem: MeasureTheory.Measure.integral_comp_inv_smul_of_nonneg
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
f : E → F
R : ℝ
hR : 0 ≤ R
⊢ ∫ (x : E), f (R⁻¹ • x) ∂μ = R ^ finrank ℝ E • ∫ (x : E), f x ∂μ
state_after: no goals
tactic: rw [integral_comp_inv_smul μ f R, abs_of_nonneg (pow_nonneg hR _)]
Theorem: MeasureTheory.setToFun_finset_sum
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
ι : Type u_7
s : Finset ι
f : ι → α → E
hf : ∀ i ∈ s, Integrable (f i) μ
⊢ (setToFun μ T hT fun a => ∑ i ∈ s, f i a) = ∑ i ∈ s, setToFun μ T hT (f i)
state_after: case h.e'_2.h.e'_14.h
α : 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
ι : Type u_7
s : Finset ι
f : ι → α → E
hf : ∀ i ∈ s, Integrable (f i) μ
a : α
⊢ ∑ i ∈ s, f i a = (∑ i ∈ s, f i) a
tactic: convert setToFun_finset_sum' hT s hf with a
state_before: case h.e'_2.h.e'_14.h
α : 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
ι : Type u_7
s : Finset ι
f : ι → α → E
hf : ∀ i ∈ s, Integrable (f i) μ
a : α
⊢ ∑ i ∈ s, f i a = (∑ i ∈ s, f i) a
state_after: no goals
tactic: simp
Theorem: minpoly.two_le_natDegree_iff
File: Mathlib/FieldTheory/Minpoly/Basic.lean

Proof steps:
state_before: A : Type u_1
B : Type u_2
B' : Type u_3
inst✝³ : CommRing A
inst✝² : Ring B
inst✝¹ : Algebra A B
x : B
inst✝ : Nontrivial B
int : IsIntegral A x
⊢ 2 ≤ (minpoly A x).natDegree ↔ x ∉ (algebraMap A B).range
state_after: A : Type u_1
B : Type u_2
B' : Type u_3
inst✝³ : CommRing A
inst✝² : Ring B
inst✝¹ : Algebra A B
x : B
inst✝ : Nontrivial B
int : IsIntegral A x
⊢ (minpoly A x).natDegree = 1 ↔ (minpoly A x).natDegree < 2
tactic: rw [iff_not_comm, ← natDegree_eq_one_iff, not_le]
state_before: A : Type u_1
B : Type u_2
B' : Type u_3
inst✝³ : CommRing A
inst✝² : Ring B
inst✝¹ : Algebra A B
x : B
inst✝ : Nontrivial B
int : IsIntegral A x
⊢ (minpoly A x).natDegree = 1 ↔ (minpoly A x).natDegree < 2
state_after: no goals
tactic: exact ⟨fun h ↦ h.trans_lt one_lt_two, fun h ↦ by linarith only [minpoly.natDegree_pos int, h]⟩
Theorem: CategoryTheory.isCofiltered_costructuredArrow_of_isCofiltered_of_exists
File: Mathlib/CategoryTheory/Filtered/Final.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝ : IsCofilteredOrEmpty C
h₁ : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
h₂ : ∀ {d : D} {c : C} (s s' : F.obj c ⟶ d), ∃ c' t, F.map t ≫ s = F.map t ≫ s'
d : D
⊢ IsCofiltered (CostructuredArrow F d)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝ : IsCofilteredOrEmpty C
h₁ : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
h₂ : ∀ {d : D} {c : C} (s s' : F.obj c ⟶ d), ∃ c' t, F.map t ≫ s = F.map t ≫ s'
d : D
⊢ IsFiltered (CostructuredArrow F d)ᵒᵖ
tactic: suffices IsFiltered (CostructuredArrow F d)ᵒᵖ from isCofiltered_of_isFiltered_op _
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝ : IsCofilteredOrEmpty C
h₁ : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
h₂ : ∀ {d : D} {c : C} (s s' : F.obj c ⟶ d), ∃ c' t, F.map t ≫ s = F.map t ≫ s'
d : D
⊢ IsFiltered (CostructuredArrow F d)ᵒᵖ
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝ : IsCofilteredOrEmpty C
h₁ : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
h₂ : ∀ {d : D} {c : C} (s s' : F.obj c ⟶ d), ∃ c' t, F.map t ≫ s = F.map t ≫ s'
d : D
⊢ IsFiltered (StructuredArrow (op d) F.op)
tactic: suffices IsFiltered (StructuredArrow (op d) F.op) from
    IsFiltered.of_equivalence (costructuredArrowOpEquivalence _ _).symm
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝ : IsCofilteredOrEmpty C
h₁ : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
h₂ : ∀ {d : D} {c : C} (s s' : F.obj c ⟶ d), ∃ c' t, F.map t ≫ s = F.map t ≫ s'
d : D
⊢ IsFiltered (StructuredArrow (op d) F.op)
state_after: case h₁
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝ : IsCofilteredOrEmpty C
h₁ : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
h₂ : ∀ {d : D} {c : C} (s s' : F.obj c ⟶ d), ∃ c' t, F.map t ≫ s = F.map t ≫ s'
d : D
⊢ ∀ (d : Dᵒᵖ), ∃ c, Nonempty (d ⟶ F.op.obj c)

case h₂
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝ : IsCofilteredOrEmpty C
h₁ : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
h₂ : ∀ {d : D} {c : C} (s s' : F.obj c ⟶ d), ∃ c' t, F.map t ≫ s = F.map t ≫ s'
d : D
⊢ ∀ {d : Dᵒᵖ} {c : Cᵒᵖ} (s s' : d ⟶ F.op.obj c), ∃ c' t, s ≫ F.op.map t = s' ≫ F.op.map t
tactic: apply isFiltered_structuredArrow_of_isFiltered_of_exists
Theorem: PowerSeries.map_sin
File: Mathlib/RingTheory/PowerSeries/WellKnown.lean

Proof steps:
state_before: A : Type u_1
A' : Type u_2
inst✝⁷ : Ring A
inst✝⁶ : Ring A'
inst✝⁵ : Algebra ℚ A
inst✝⁴ : Algebra ℚ A'
inst✝³ : Ring A
inst✝² : Ring A'
inst✝¹ : Algebra ℚ A
inst✝ : Algebra ℚ A'
n : ℕ
f : A →+* A'
⊢ (map f) (sin A) = sin A'
state_after: case h
A : Type u_1
A' : Type u_2
inst✝⁷ : Ring A
inst✝⁶ : Ring A'
inst✝⁵ : Algebra ℚ A
inst✝⁴ : Algebra ℚ A'
inst✝³ : Ring A
inst✝² : Ring A'
inst✝¹ : Algebra ℚ A
inst✝ : Algebra ℚ A'
n : ℕ
f : A →+* A'
n✝ : ℕ
⊢ (coeff A' n✝) ((map f) (sin A)) = (coeff A' n✝) (sin A')
tactic: ext
state_before: case h
A : Type u_1
A' : Type u_2
inst✝⁷ : Ring A
inst✝⁶ : Ring A'
inst✝⁵ : Algebra ℚ A
inst✝⁴ : Algebra ℚ A'
inst✝³ : Ring A
inst✝² : Ring A'
inst✝¹ : Algebra ℚ A
inst✝ : Algebra ℚ A'
n : ℕ
f : A →+* A'
n✝ : ℕ
⊢ (coeff A' n✝) ((map f) (sin A)) = (coeff A' n✝) (sin A')
state_after: no goals
tactic: simp [sin, apply_ite f]
Theorem: CategoryTheory.Abelian.coimage_image_factorisation
File: Mathlib/CategoryTheory/Abelian/Images.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasKernels C
inst✝ : HasCokernels C
P Q : C
f : P ⟶ Q
⊢ coimage.π f ≫ coimageImageComparison f ≫ image.ι f = f
state_after: no goals
tactic: simp [coimageImageComparison]
Theorem: List.toFinsupp_nil
File: Mathlib/Data/List/ToFinsupp.lean

Proof steps:
state_before: M : Type u_1
inst✝² : Zero M
l : List M
inst✝¹ : DecidablePred fun x => l.getD x 0 ≠ 0
n : ℕ
inst✝ : DecidablePred fun i => [].getD i 0 ≠ 0
⊢ [].toFinsupp = 0
state_after: case h
M : Type u_1
inst✝² : Zero M
l : List M
inst✝¹ : DecidablePred fun x => l.getD x 0 ≠ 0
n : ℕ
inst✝ : DecidablePred fun i => [].getD i 0 ≠ 0
a✝ : ℕ
⊢ [].toFinsupp a✝ = 0 a✝
tactic: ext
state_before: case h
M : Type u_1
inst✝² : Zero M
l : List M
inst✝¹ : DecidablePred fun x => l.getD x 0 ≠ 0
n : ℕ
inst✝ : DecidablePred fun i => [].getD i 0 ≠ 0
a✝ : ℕ
⊢ [].toFinsupp a✝ = 0 a✝
state_after: no goals
tactic: simp
Theorem: Matrix.mulVec_neg
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✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype n
v : n → α
A : Matrix m n α
⊢ A *ᵥ -v = -(A *ᵥ v)
state_after: case h
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✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype n
v : n → α
A : Matrix m n α
x✝ : m
⊢ (A *ᵥ -v) x✝ = (-(A *ᵥ v)) x✝
tactic: ext
state_before: case h
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✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype n
v : n → α
A : Matrix m n α
x✝ : m
⊢ (A *ᵥ -v) x✝ = (-(A *ᵥ v)) x✝
state_after: no goals
tactic: apply dotProduct_neg
Theorem: Polynomial.leadingCoeff_prod
File: Mathlib/Algebra/Polynomial/BigOperators.lean

Proof steps:
state_before: R : Type u
ι : Type w
s : Finset ι
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
f : ι → R[X]
t : Multiset R[X]
⊢ (∏ i ∈ s, f i).leadingCoeff = ∏ i ∈ s, (f i).leadingCoeff
state_after: no goals
tactic: simpa using leadingCoeff_multiset_prod (s.1.map f)
Theorem: AlgebraicGeometry.IsOpenImmersion.range_pullback_snd_of_left
File: Mathlib/AlgebraicGeometry/OpenImmersion.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : Scheme
f : X ⟶ Z
g : Y ⟶ Z
H : IsOpenImmersion f
⊢ Set.range ⇑(pullback.snd f g).val.base = (g ⁻¹ᵁ Scheme.Hom.opensRange f).carrier
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y Z : Scheme
f : X ⟶ Z
g : Y ⟶ Z
H : IsOpenImmersion f
⊢ ⇑(pullback.snd (Scheme.forgetToTop.map f) (Scheme.forgetToTop.map g)) ''
      (⇑(pullback.fst f.val.base g.val.base) ⁻¹' Set.univ) =
    (g ⁻¹ᵁ Scheme.Hom.opensRange f).carrier

C : Type u
inst✝ : Category.{v, u} C
X Y Z : Scheme
f : X ⟶ Z
g : Y ⟶ Z
H : IsOpenImmersion f
⊢ Function.Surjective ⇑(PreservesPullback.iso Scheme.forgetToTop f g).hom
tactic: rw [← show _ = (pullback.snd f g).1.base from
    PreservesPullback.iso_hom_snd Scheme.forgetToTop f g, TopCat.coe_comp, Set.range_comp,
    Set.range_iff_surjective.mpr, ← @Set.preimage_univ _ _ (pullback.fst f.1.base g.1.base)]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : Scheme
f : X ⟶ Z
g : Y ⟶ Z
H : IsOpenImmersion f
⊢ Function.Surjective ⇑(PreservesPullback.iso Scheme.forgetToTop f g).hom
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y Z : Scheme
f : X ⟶ Z
g : Y ⟶ Z
H : IsOpenImmersion f
⊢ Epi (PreservesPullback.iso Scheme.forgetToTop f g).hom
tactic: rw [← TopCat.epi_iff_surjective]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : Scheme
f : X ⟶ Z
g : Y ⟶ Z
H : IsOpenImmersion f
⊢ Epi (PreservesPullback.iso Scheme.forgetToTop f g).hom
state_after: no goals
tactic: infer_instance
Theorem: Polynomial.Monic.isRegular
File: Mathlib/Algebra/Polynomial/Monic.lean

Proof steps:
state_before: R✝ : Type u
S : Type v
a b : R✝
m n : ℕ
ι : Type y
inst✝¹ : Semiring R✝
p✝ : R✝[X]
R : Type u_1
inst✝ : Ring R
p : R[X]
hp : p.Monic
⊢ IsRegular p
state_after: case left
R✝ : Type u
S : Type v
a b : R✝
m n : ℕ
ι : Type y
inst✝¹ : Semiring R✝
p✝ : R✝[X]
R : Type u_1
inst✝ : Ring R
p : R[X]
hp : p.Monic
⊢ IsLeftRegular p

case right
R✝ : Type u
S : Type v
a b : R✝
m n : ℕ
ι : Type y
inst✝¹ : Semiring R✝
p✝ : R✝[X]
R : Type u_1
inst✝ : Ring R
p : R[X]
hp : p.Monic
⊢ IsRightRegular p
tactic: constructor
Theorem: SModEq.neg
File: Mathlib/LinearAlgebra/SModEq.lean

Proof steps:
state_before: R : Type u_1
inst✝⁵ : Ring R
A : Type u_2
inst✝⁴ : CommRing A
M : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
U U₁ U₂ : Submodule R M
x x₁ x₂ y y₁ y₂ z z₁ z₂ : M
N : Type u_4
inst✝¹ : AddCommGroup N
inst✝ : Module R N
V V₁ V₂ : Submodule R N
hxy : x ≡ y [SMOD U]
⊢ -x ≡ -y [SMOD U]
state_after: no goals
tactic: simpa only [SModEq.def, Quotient.mk_neg, neg_inj]
Theorem: Nat.nth_lt_of_lt_count
File: Mathlib/Data/Nat/Nth.lean

Proof steps:
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
n k : ℕ
h : k < count p n
⊢ nth p k < n
state_after: p : ℕ → Prop
inst✝ : DecidablePred p
n k : ℕ
h : k < count p n
⊢ count p (nth p k) < count p n
tactic: refine (count_monotone p).reflect_lt ?_
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
n k : ℕ
h : k < count p n
⊢ count p (nth p k) < count p n
state_after: p : ℕ → Prop
inst✝ : DecidablePred p
n k : ℕ
h : k < count p n
⊢ ∀ (hf : (setOf p).Finite), k < hf.toFinset.card
tactic: rwa [count_nth]
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
n k : ℕ
h : k < count p n
⊢ ∀ (hf : (setOf p).Finite), k < hf.toFinset.card
state_after: no goals
tactic: exact fun hf => h.trans_le (count_le_card hf n)