ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: VonNeumannAlgebra.commutant_commutant
File: Mathlib/Analysis/VonNeumannAlgebra/Basic.lean

Proof steps:
state_before: H : Type u
inst✝² : NormedAddCommGroup H
inst✝¹ : InnerProductSpace ℂ H
inst✝ : CompleteSpace H
S : VonNeumannAlgebra H
⊢ ↑S.commutant.commutant = ↑S
state_after: no goals
tactic: simp
Theorem: HomologicalComplex₂.D₂_D₂
File: Mathlib/Algebra/Homology/TotalComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝² : DecidableEq I₁₂
inst✝¹ : TotalComplexShape c₁ c₂ c₁₂
inst✝ : K.HasTotal c₁₂
i₁₂ i₁₂' i₁₂'' : I₁₂
⊢ K.D₂ c₁₂ i₁₂ i₁₂' ≫ K.D₂ c₁₂ i₁₂' i₁₂'' = 0
state_after: case pos
C : Type u_1
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝² : DecidableEq I₁₂
inst✝¹ : TotalComplexShape c₁ c₂ c₁₂
inst✝ : K.HasTotal c₁₂
i₁₂ i₁₂' i₁₂'' : I₁₂
h₁ : c₁₂.Rel i₁₂ i₁₂'
⊢ K.D₂ c₁₂ i₁₂ i₁₂' ≫ K.D₂ c₁₂ i₁₂' i₁₂'' = 0

case neg
C : Type u_1
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝² : DecidableEq I₁₂
inst✝¹ : TotalComplexShape c₁ c₂ c₁₂
inst✝ : K.HasTotal c₁₂
i₁₂ i₁₂' i₁₂'' : I₁₂
h₁ : ¬c₁₂.Rel i₁₂ i₁₂'
⊢ K.D₂ c₁₂ i₁₂ i₁₂' ≫ K.D₂ c₁₂ i₁₂' i₁₂'' = 0
tactic: by_cases h₁ : c₁₂.Rel i₁₂ i₁₂'
Theorem: OnePoint.tendsto_coe_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
⊢ Tendsto some (coclosedCompact X) (𝓝 ∞)
state_after: X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
⊢ Tendsto some (coclosedCompact X) (map some (coclosedCompact X) ⊔ pure ∞)
tactic: rw [nhds_infty_eq]
state_before: X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
⊢ Tendsto some (coclosedCompact X) (map some (coclosedCompact X) ⊔ pure ∞)
state_after: no goals
tactic: exact Filter.Tendsto.mono_right tendsto_map le_sup_left
Theorem: Complex.integral_boundary_rect_eq_zero_of_differentiable_on_off_countable
File: Mathlib/Analysis/Complex/CauchyIntegral.lean

Proof steps:
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
z w : ℂ
s : Set ℂ
hs : s.Countable
Hc : ContinuousOn f ([[z.re, w.re]] ×ℂ [[z.im, w.im]])
Hd : ∀ x ∈ Ioo (min z.re w.re) (max z.re w.re) ×ℂ Ioo (min z.im w.im) (max z.im w.im) \ s, DifferentiableAt ℂ f x
⊢ (((∫ (x : ℝ) in z.re..w.re, f (↑x + ↑z.im * I)) - ∫ (x : ℝ) in z.re..w.re, f (↑x + ↑w.im * I)) +
        I • ∫ (y : ℝ) in z.im..w.im, f (↑w.re + ↑y * I)) -
      I • ∫ (y : ℝ) in z.im..w.im, f (↑z.re + ↑y * I) =
    0
state_after: no goals
tactic: refine (integral_boundary_rect_of_hasFDerivAt_real_off_countable f
    (fun z => (fderiv ℂ f z).restrictScalars ℝ) z w s hs Hc
    (fun x hx => (Hd x hx).hasFDerivAt.restrictScalars ℝ) ?_).trans ?_ <;>
      simp [← ContinuousLinearMap.map_smul]
Theorem: Set.pi_if
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s✝ s₁ s₂ : Set ι
t t₁✝ t₂✝ : (i : ι) → Set (α i)
i : ι
p : ι → Prop
h : DecidablePred p
s : Set ι
t₁ t₂ : (i : ι) → Set (α i)
⊢ (s.pi fun i => if p i then t₁ i else t₂ i) = {i | i ∈ s ∧ p i}.pi t₁ ∩ {i | i ∈ s ∧ ¬p i}.pi t₂
state_after: case h
ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s✝ s₁ s₂ : Set ι
t t₁✝ t₂✝ : (i : ι) → Set (α i)
i : ι
p : ι → Prop
h : DecidablePred p
s : Set ι
t₁ t₂ : (i : ι) → Set (α i)
f : (i : ι) → α i
⊢ (f ∈ s.pi fun i => if p i then t₁ i else t₂ i) ↔ f ∈ {i | i ∈ s ∧ p i}.pi t₁ ∩ {i | i ∈ s ∧ ¬p i}.pi t₂
tactic: ext f
state_before: case h
ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s✝ s₁ s₂ : Set ι
t t₁✝ t₂✝ : (i : ι) → Set (α i)
i : ι
p : ι → Prop
h : DecidablePred p
s : Set ι
t₁ t₂ : (i : ι) → Set (α i)
f : (i : ι) → α i
⊢ (f ∈ s.pi fun i => if p i then t₁ i else t₂ i) ↔ f ∈ {i | i ∈ s ∧ p i}.pi t₁ ∩ {i | i ∈ s ∧ ¬p i}.pi t₂
state_after: case h.refine_1
ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s✝ s₁ s₂ : Set ι
t t₁✝ t₂✝ : (i : ι) → Set (α i)
i : ι
p : ι → Prop
h✝ : DecidablePred p
s : Set ι
t₁ t₂ : (i : ι) → Set (α i)
f : (i : ι) → α i
h : f ∈ s.pi fun i => if p i then t₁ i else t₂ i
⊢ f ∈ {i | i ∈ s ∧ p i}.pi t₁ ∩ {i | i ∈ s ∧ ¬p i}.pi t₂

case h.refine_2
ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s✝ s₁ s₂ : Set ι
t t₁✝ t₂✝ : (i : ι) → Set (α i)
i : ι
p : ι → Prop
h : DecidablePred p
s : Set ι
t₁ t₂ : (i : ι) → Set (α i)
f : (i : ι) → α i
⊢ f ∈ {i | i ∈ s ∧ p i}.pi t₁ ∩ {i | i ∈ s ∧ ¬p i}.pi t₂ → f ∈ s.pi fun i => if p i then t₁ i else t₂ i
tactic: refine ⟨fun h => ?_, ?_⟩
Theorem: MeasureTheory.withDensity_indicator
File: Mathlib/MeasureTheory/Measure/WithDensity.lean

Proof steps:
state_before: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
s : Set α
hs : MeasurableSet s
f : α → ℝ≥0∞
⊢ μ.withDensity (s.indicator f) = (μ.restrict s).withDensity f
state_after: case h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
s : Set α
hs : MeasurableSet s
f : α → ℝ≥0∞
t : Set α
ht : MeasurableSet t
⊢ (μ.withDensity (s.indicator f)) t = ((μ.restrict s).withDensity f) t
tactic: ext1 t ht
state_before: case h
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
s : Set α
hs : MeasurableSet s
f : α → ℝ≥0∞
t : Set α
ht : MeasurableSet t
⊢ (μ.withDensity (s.indicator f)) t = ((μ.restrict s).withDensity f) t
state_after: no goals
tactic: rw [withDensity_apply _ ht, lintegral_indicator _ hs, restrict_comm hs, ←
    withDensity_apply _ ht]
Theorem: div_right_injective
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✝ : Group G
a b c d : G
n : ℤ
⊢ Injective fun a => b / a
state_after: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
⊢ Injective fun a => b * a⁻¹
tactic: simp only [div_eq_mul_inv]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
⊢ Injective fun a => b * a⁻¹
state_after: no goals
tactic: exact fun a a' h ↦ inv_injective (mul_right_injective b h)
Theorem: QuadraticMap.polar_smul
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

Proof steps:
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
A : Type u_7
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Monoid S
inst✝ : DistribMulAction S N
f : M → N
s : S
x y : M
⊢ polar (s • f) x y = s • polar f x y
state_after: no goals
tactic: simp only [polar, Pi.smul_apply, smul_sub]
Theorem: MvPolynomial.IsHomogeneous.eq_zero_of_forall_eval_eq_zero
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

Proof steps:
state_before: σ✝ : Type u_1
τ : Type u_2
R✝ : Type u_3
S : Type u_4
inst✝⁵ inst✝⁴ : CommSemiring R✝
inst✝³ : CommSemiring S
φ ψ : MvPolynomial σ✝ R✝
m n✝¹ : ℕ
R : Type u_5
σ : Type u_6
inst✝² : CommRing R
inst✝¹ : IsDomain R
F✝ G : MvPolynomial σ R
n✝ : ℕ
inst✝ : Infinite R
F : MvPolynomial σ R
n : ℕ
hF : F.IsHomogeneous n
h : ∀ (r : σ → R), (eval r) F = 0
⊢ F = 0
state_after: σ✝ : Type u_1
τ : Type u_2
R✝ : Type u_3
S : Type u_4
inst✝⁵ inst✝⁴ : CommSemiring R✝
inst✝³ : CommSemiring S
φ ψ : MvPolynomial σ✝ R✝
m n✝¹ : ℕ
R : Type u_5
σ : Type u_6
inst✝² : CommRing R
inst✝¹ : IsDomain R
F✝ G : MvPolynomial σ R
n✝ : ℕ
inst✝ : Infinite R
F : MvPolynomial σ R
n : ℕ
hF : F.IsHomogeneous n
h : ∀ (r : σ → R), (eval r) F = 0
⊢ ↑n ≤ #R
tactic: apply eq_zero_of_forall_eval_eq_zero_of_le_card hF h
state_before: σ✝ : Type u_1
τ : Type u_2
R✝ : Type u_3
S : Type u_4
inst✝⁵ inst✝⁴ : CommSemiring R✝
inst✝³ : CommSemiring S
φ ψ : MvPolynomial σ✝ R✝
m n✝¹ : ℕ
R : Type u_5
σ : Type u_6
inst✝² : CommRing R
inst✝¹ : IsDomain R
F✝ G : MvPolynomial σ R
n✝ : ℕ
inst✝ : Infinite R
F : MvPolynomial σ R
n : ℕ
hF : F.IsHomogeneous n
h : ∀ (r : σ → R), (eval r) F = 0
⊢ ↑n ≤ #R
state_after: no goals
tactic: exact (Cardinal.nat_lt_aleph0 _).le.trans <| Cardinal.infinite_iff.mp ‹Infinite R›
Theorem: MeasureTheory.ExistsSeqTendstoAe.seqTendstoAeSeq_strictMono
File: Mathlib/MeasureTheory/Function/ConvergenceInMeasure.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : MetricSpace E
f : ℕ → α → E
g : α → E
hfg : TendstoInMeasure μ f atTop g
⊢ StrictMono (seqTendstoAeSeq hfg)
state_after: α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : MetricSpace E
f : ℕ → α → E
g : α → E
hfg : TendstoInMeasure μ f atTop g
n : ℕ
⊢ seqTendstoAeSeq hfg n < seqTendstoAeSeq hfg (n + 1)
tactic: refine strictMono_nat_of_lt_succ fun n => ?_
state_before: α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : MetricSpace E
f : ℕ → α → E
g : α → E
hfg : TendstoInMeasure μ f atTop g
n : ℕ
⊢ seqTendstoAeSeq hfg n < seqTendstoAeSeq hfg (n + 1)
state_after: α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : MetricSpace E
f : ℕ → α → E
g : α → E
hfg : TendstoInMeasure μ f atTop g
n : ℕ
⊢ seqTendstoAeSeq hfg n < max (seqTendstoAeSeqAux hfg (n + 1)) (seqTendstoAeSeq hfg n + 1)
tactic: rw [seqTendstoAeSeq_succ]
state_before: α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : MetricSpace E
f : ℕ → α → E
g : α → E
hfg : TendstoInMeasure μ f atTop g
n : ℕ
⊢ seqTendstoAeSeq hfg n < max (seqTendstoAeSeqAux hfg (n + 1)) (seqTendstoAeSeq hfg n + 1)
state_after: no goals
tactic: exact lt_of_lt_of_le (lt_add_one <| seqTendstoAeSeq hfg n) (le_max_right _ _)
Theorem: UV.compress_injOn
File: Mathlib/Combinatorics/SetFamily/Compression/UV.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : GeneralizedBooleanAlgebra α
inst✝² : DecidableRel Disjoint
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a b : α
inst✝ : DecidableEq α
⊢ Set.InjOn (compress u v) ↑(filter (fun x => compress u v x ∉ s) s)
state_after: α : Type u_1
inst✝³ : GeneralizedBooleanAlgebra α
inst✝² : DecidableRel Disjoint
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a✝ b✝ : α
inst✝ : DecidableEq α
a : α
ha : a ∈ ↑(filter (fun x => compress u v x ∉ s) s)
b : α
hb : b ∈ ↑(filter (fun x => compress u v x ∉ s) s)
hab : compress u v a = compress u v b
⊢ a = b
tactic: intro a ha b hb hab
state_before: α : Type u_1
inst✝³ : GeneralizedBooleanAlgebra α
inst✝² : DecidableRel Disjoint
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a✝ b✝ : α
inst✝ : DecidableEq α
a : α
ha : a ∈ ↑(filter (fun x => compress u v x ∉ s) s)
b : α
hb : b ∈ ↑(filter (fun x => compress u v x ∉ s) s)
hab : compress u v a = compress u v b
⊢ a = b
state_after: α : Type u_1
inst✝³ : GeneralizedBooleanAlgebra α
inst✝² : DecidableRel Disjoint
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a✝ b✝ : α
inst✝ : DecidableEq α
a : α
ha : a ∈ s ∧ compress u v a ∉ s
b : α
hb : b ∈ s ∧ compress u v b ∉ s
hab : compress u v a = compress u v b
⊢ a = b
tactic: rw [mem_coe, mem_filter] at ha hb
state_before: α : Type u_1
inst✝³ : GeneralizedBooleanAlgebra α
inst✝² : DecidableRel Disjoint
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a✝ b✝ : α
inst✝ : DecidableEq α
a : α
ha : a ∈ s ∧ compress u v a ∉ s
b : α
hb : b ∈ s ∧ compress u v b ∉ s
hab : compress u v a = compress u v b
⊢ a = b
state_after: α : Type u_1
inst✝³ : GeneralizedBooleanAlgebra α
inst✝² : DecidableRel Disjoint
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a✝ b✝ : α
inst✝ : DecidableEq α
a : α
ha : a ∈ s ∧ (if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a) ∉ s
b : α
hb : b ∈ s ∧ compress u v b ∉ s
hab : (if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a) = compress u v b
⊢ a = b
tactic: rw [compress] at ha hab
state_before: α : Type u_1
inst✝³ : GeneralizedBooleanAlgebra α
inst✝² : DecidableRel Disjoint
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a✝ b✝ : α
inst✝ : DecidableEq α
a : α
ha : a ∈ s ∧ (if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a) ∉ s
b : α
hb : b ∈ s ∧ compress u v b ∉ s
hab : (if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a) = compress u v b
⊢ a = b
state_after: case pos
α : Type u_1
inst✝³ : GeneralizedBooleanAlgebra α
inst✝² : DecidableRel Disjoint
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a✝ b✝ : α
inst✝ : DecidableEq α
a b : α
hb : b ∈ s ∧ compress u v b ∉ s
has : Disjoint u a ∧ v ≤ a
ha : a ∈ s ∧ (a ⊔ u) \ v ∉ s
hab : (a ⊔ u) \ v = compress u v b
⊢ a = b

case neg
α : Type u_1
inst✝³ : GeneralizedBooleanAlgebra α
inst✝² : DecidableRel Disjoint
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u v a✝ b✝ : α
inst✝ : DecidableEq α
a b : α
hb : b ∈ s ∧ compress u v b ∉ s
has : ¬(Disjoint u a ∧ v ≤ a)
ha : a ∈ s ∧ a ∉ s
hab : a = compress u v b
⊢ a = b
tactic: split_ifs at ha hab with has
Theorem: lowerSemicontinuous_iff_isClosed_preimage
File: Mathlib/Topology/Semicontinuous.lean

Proof steps:
state_before: α : Type u_1
inst✝² : TopologicalSpace α
β : Type u_2
inst✝¹ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
γ : Type u_3
inst✝ : LinearOrder γ
f : α → γ
⊢ LowerSemicontinuous f ↔ ∀ (y : γ), IsClosed (f ⁻¹' Iic y)
state_after: α : Type u_1
inst✝² : TopologicalSpace α
β : Type u_2
inst✝¹ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
γ : Type u_3
inst✝ : LinearOrder γ
f : α → γ
⊢ (∀ (y : γ), IsOpen (f ⁻¹' Ioi y)) ↔ ∀ (y : γ), IsClosed (f ⁻¹' Iic y)
tactic: rw [lowerSemicontinuous_iff_isOpen_preimage]
state_before: α : Type u_1
inst✝² : TopologicalSpace α
β : Type u_2
inst✝¹ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
γ : Type u_3
inst✝ : LinearOrder γ
f : α → γ
⊢ (∀ (y : γ), IsOpen (f ⁻¹' Ioi y)) ↔ ∀ (y : γ), IsClosed (f ⁻¹' Iic y)
state_after: no goals
tactic: simp only [← isOpen_compl_iff, ← preimage_compl, compl_Iic]
Theorem: CategoryTheory.Localization.hasSmallLocalizedHom_iff_of_isos
File: Mathlib/CategoryTheory/Localization/SmallHom.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
W : MorphismProperty C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
D' : Type u₃
inst✝¹ : Category.{v₃, u₃} D'
L : C ⥤ D
inst✝ : L.IsLocalization W
X Y Z X' Y' : C
e : X ≅ X'
e' : Y ≅ Y'
⊢ HasSmallLocalizedHom W X Y ↔ HasSmallLocalizedHom W X' Y'
state_after: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
W : MorphismProperty C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
D' : Type u₃
inst✝¹ : Category.{v₃, u₃} D'
L : C ⥤ D
inst✝ : L.IsLocalization W
X Y Z X' Y' : C
e : X ≅ X'
e' : Y ≅ Y'
⊢ Small.{w, max u₁ v₁} (W.Q.obj X ⟶ W.Q.obj Y) ↔ Small.{w, max u₁ v₁} (W.Q.obj X' ⟶ W.Q.obj Y')
tactic: simp only [hasSmallLocalizedHom_iff W W.Q]
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
W : MorphismProperty C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
D' : Type u₃
inst✝¹ : Category.{v₃, u₃} D'
L : C ⥤ D
inst✝ : L.IsLocalization W
X Y Z X' Y' : C
e : X ≅ X'
e' : Y ≅ Y'
⊢ Small.{w, max u₁ v₁} (W.Q.obj X ⟶ W.Q.obj Y) ↔ Small.{w, max u₁ v₁} (W.Q.obj X' ⟶ W.Q.obj Y')
state_after: no goals
tactic: exact small_congr (Iso.homCongr (W.Q.mapIso e) (W.Q.mapIso e'))
Theorem: Set.encard_union_le
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s✝ t✝ s t : Set α
⊢ (s ∪ t).encard ≤ s.encard + t.encard
state_after: α : Type u_1
β : Type u_2
s✝ t✝ s t : Set α
⊢ (s ∪ t).encard ≤ (s ∪ t).encard + (s ∩ t).encard
tactic: rw [← encard_union_add_encard_inter]
state_before: α : Type u_1
β : Type u_2
s✝ t✝ s t : Set α
⊢ (s ∪ t).encard ≤ (s ∪ t).encard + (s ∩ t).encard
state_after: no goals
tactic: exact le_self_add
Theorem: Rat.num_lt_succ_floor_mul_den
File: Mathlib/Data/Rat/Floor.lean

Proof steps:
state_before: q : ℚ
⊢ q.num < (⌊q⌋ + 1) * ↑q.den
state_after: q : ℚ
⊢ ↑q.num < (↑⌊q⌋ + 1) * ↑q.den
tactic: suffices (q.num : ℚ) < (⌊q⌋ + 1) * q.den from mod_cast this
state_before: q : ℚ
⊢ ↑q.num < (↑⌊q⌋ + 1) * ↑q.den
state_after: q : ℚ
⊢ ↑q.num < (q - fract q + 1) * ↑q.den
tactic: suffices (q.num : ℚ) < (q - fract q + 1) * q.den by
    have : (⌊q⌋ : ℚ) = q - fract q := eq_sub_of_add_eq <| floor_add_fract q
    rwa [this]
state_before: q : ℚ
⊢ ↑q.num < (q - fract q + 1) * ↑q.den
state_after: q : ℚ
⊢ ↑q.num < ↑q.num + (1 - fract q) * ↑q.den
tactic: suffices (q.num : ℚ) < q.num + (1 - fract q) * q.den by
    have : (q - fract q + 1) * q.den = q.num + (1 - fract q) * q.den := by
      calc
        (q - fract q + 1) * q.den = (q + (1 - fract q)) * q.den := by ring
        _ = q * q.den + (1 - fract q) * q.den := by rw [add_mul]
        _ = q.num + (1 - fract q) * q.den := by simp
    rwa [this]
state_before: q : ℚ
⊢ ↑q.num < ↑q.num + (1 - fract q) * ↑q.den
state_after: q : ℚ
⊢ 0 < (1 - fract q) * ↑q.den
tactic: suffices 0 < (1 - fract q) * q.den by
    rw [← sub_lt_iff_lt_add']
    simpa
state_before: q : ℚ
⊢ 0 < (1 - fract q) * ↑q.den
state_after: q : ℚ
this : 0 < 1 - fract q
⊢ 0 < (1 - fract q) * ↑q.den
tactic: have : 0 < 1 - fract q := by
    have : fract q < 1 := fract_lt_one q
    have : 0 + fract q < 1 := by simp [this]
    rwa [lt_sub_iff_add_lt]
state_before: q : ℚ
this : 0 < 1 - fract q
⊢ 0 < (1 - fract q) * ↑q.den
state_after: no goals
tactic: exact mul_pos this (by exact mod_cast q.pos)
Theorem: Nat.choose_le_succ_of_lt_half_left
File: Mathlib/Data/Nat/Choose/Basic.lean

Proof steps:
state_before: r n : ℕ
h : r < n / 2
⊢ n.choose r ≤ n.choose (r + 1)
state_after: r n : ℕ
h : r < n / 2
⊢ n.choose r * (n - r) ≤ n.choose (r + 1) * (n - r)
tactic: refine Nat.le_of_mul_le_mul_right ?_ (Nat.sub_pos_of_lt (h.trans_le (n.div_le_self 2)))
state_before: r n : ℕ
h : r < n / 2
⊢ n.choose r * (n - r) ≤ n.choose (r + 1) * (n - r)
state_after: r n : ℕ
h : r < n / 2
⊢ n.choose (r + 1) * (r + 1) ≤ n.choose (r + 1) * (n - r)
tactic: rw [← choose_succ_right_eq]
state_before: r n : ℕ
h : r < n / 2
⊢ n.choose (r + 1) * (r + 1) ≤ n.choose (r + 1) * (n - r)
state_after: case h
r n : ℕ
h : r < n / 2
⊢ r + 1 ≤ n - r
tactic: apply Nat.mul_le_mul_left
state_before: case h
r n : ℕ
h : r < n / 2
⊢ r + 1 ≤ n - r
state_after: case h
r n : ℕ
h : r < n / 2
⊢ r * 2 < n
tactic: rw [← Nat.lt_iff_add_one_le, Nat.lt_sub_iff_add_lt, ← Nat.mul_two]
state_before: case h
r n : ℕ
h : r < n / 2
⊢ r * 2 < n
state_after: no goals
tactic: exact lt_of_lt_of_le (Nat.mul_lt_mul_of_pos_right h Nat.zero_lt_two) (n.div_mul_le_self 2)
Theorem: Filter.frequently_sSup
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p : α → Prop
fs : Set (Filter α)
⊢ (∃ᶠ (x : α) in sSup fs, p x) ↔ ∃ f ∈ fs, ∃ᶠ (x : α) in f, p x
state_after: no goals
tactic: simp only [Filter.Frequently, not_forall, eventually_sSup, exists_prop]
Theorem: Int.floor_natCast
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ : α
n : ℕ
a : ℤ
⊢ a ≤ ⌊↑n⌋ ↔ a ≤ ↑n
state_after: no goals
tactic: rw [le_floor, ← cast_natCast, cast_le]
Theorem: CategoryTheory.SimplicialObject.cechNerveEquiv_apply
File: Mathlib/AlgebraicTopology/CechNerve.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
⊢ Function.LeftInverse (equivalenceRightToLeft X F) (equivalenceLeftToRight X F)
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
A : Augmented.toArrow.obj X ⟶ F
⊢ equivalenceRightToLeft X F (equivalenceLeftToRight X F A) = A
tactic: intro A
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
A : Augmented.toArrow.obj X ⟶ F
⊢ equivalenceRightToLeft X F (equivalenceLeftToRight X F A) = A
state_after: case h₁
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
A : Augmented.toArrow.obj X ⟶ F
⊢ (equivalenceRightToLeft X F (equivalenceLeftToRight X F A)).left = A.left

case h₂
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
A : Augmented.toArrow.obj X ⟶ F
⊢ (equivalenceRightToLeft X F (equivalenceLeftToRight X F A)).right = A.right
tactic: ext
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
⊢ Function.RightInverse (equivalenceRightToLeft X F) (equivalenceLeftToRight X F)
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
A : X ⟶ F.augmentedCechNerve
⊢ equivalenceLeftToRight X F (equivalenceRightToLeft X F A) = A
tactic: intro A
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
A : X ⟶ F.augmentedCechNerve
⊢ equivalenceLeftToRight X F (equivalenceRightToLeft X F A) = A
state_after: case h₁.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
A : X ⟶ F.augmentedCechNerve
x : SimplexCategoryᵒᵖ
⊢ (equivalenceLeftToRight X F (equivalenceRightToLeft X F A)).left.app x = A.left.app x

case h₂
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
A : X ⟶ F.augmentedCechNerve
⊢ (equivalenceLeftToRight X F (equivalenceRightToLeft X F A)).right = A.right
tactic: ext x : 2
Theorem: CategoryTheory.Functor.OfSequence.map_id
File: Mathlib/CategoryTheory/Functor/OfSequence.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{?u.3026, u_1} C
X : ℕ → C
f : (n : ℕ) → X n ⟶ X (n + 1)
i : ℕ
⊢ i ≤ i
state_after: no goals
tactic: omega
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : ℕ → C
f : (n : ℕ) → X n ⟶ X (n + 1)
i : ℕ
⊢ map f i i ⋯ = 𝟙 (X i)
state_after: C : Type u_1
inst✝ : Category.{u_2, u_1} C
i : ℕ
⊢ ∀ {X : ℕ → C} (f : (n : ℕ) → X n ⟶ X (n + 1)), map f i i ⋯ = 𝟙 (X i)
tactic: revert X f
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
i : ℕ
⊢ ∀ {X : ℕ → C} (f : (n : ℕ) → X n ⟶ X (n + 1)), map f i i ⋯ = 𝟙 (X i)
state_after: no goals
tactic: induction i with
  | zero => intros; rfl
  | succ _ hi =>
      intro X f
      apply hi
Theorem: MeasureTheory.Measure.toSignedMeasure_zero
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
⊢ toSignedMeasure 0 = 0
state_after: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
i : Set α
a✝ : MeasurableSet i
⊢ ↑(toSignedMeasure 0) i = ↑0 i
tactic: ext i
state_before: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
i : Set α
a✝ : MeasurableSet i
⊢ ↑(toSignedMeasure 0) i = ↑0 i
state_after: no goals
tactic: simp