ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Surreal.dyadicMap_apply_pow
File: Mathlib/SetTheory/Surreal/Dyadic.lean

Proof steps:
state_before: m : ℤ
n : ℕ
⊢ dyadicMap (IsLocalization.mk' (Localization (Submonoid.powers 2)) m (Submonoid.pow 2 n)) = m • powHalf n
state_after: m : ℤ
n : ℕ
⊢ ↑m * powHalf n = m • powHalf n
tactic: rw [dyadicMap_apply, @Submonoid.log_pow_int_eq_self 2 one_lt_two]
state_before: m : ℤ
n : ℕ
⊢ ↑m * powHalf n = m • powHalf n
state_after: no goals
tactic: simp only [zsmul_eq_mul]
Theorem: CategoryTheory.Subobject.factorThru_ofLE
File: Mathlib/CategoryTheory/Subobject/FactorThru.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y✝ Z✝ : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
Y Z : C
P Q : Subobject Y
f : Z ⟶ Y
h : P ≤ Q
w : P.Factors f
⊢ Q.factorThru f ⋯ = P.factorThru f w ≫ P.ofLE Q h
state_after: case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y✝ Z✝ : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
Y Z : C
P Q : Subobject Y
f : Z ⟶ Y
h : P ≤ Q
w : P.Factors f
⊢ Q.factorThru f ⋯ ≫ Q.arrow = (P.factorThru f w ≫ P.ofLE Q h) ≫ Q.arrow
tactic: ext
state_before: case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y✝ Z✝ : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
Y Z : C
P Q : Subobject Y
f : Z ⟶ Y
h : P ≤ Q
w : P.Factors f
⊢ Q.factorThru f ⋯ ≫ Q.arrow = (P.factorThru f w ≫ P.ofLE Q h) ≫ Q.arrow
state_after: no goals
tactic: simp
Theorem: Submodule.LinearDisjoint.of_basis_left'
File: Mathlib/LinearAlgebra/LinearDisjoint.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
ι : Type u_1
m : Basis ι R ↥M
H : Function.Injective ⇑(mulLeftMap N ⇑m)
⊢ M.LinearDisjoint N
state_after: R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
ι : Type u_1
m : Basis ι R ↥M
H : Function.Injective ⇑(M.mulMap N)
⊢ M.LinearDisjoint N
tactic: classical simp_rw [mulLeftMap_eq_mulMap_comp, ← Basis.coe_repr_symm,
    ← LinearEquiv.coe_rTensor, LinearEquiv.comp_coe, LinearMap.coe_comp,
    LinearEquiv.coe_coe, EquivLike.injective_comp] at H
state_before: R : Type u
S : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
M N : Submodule R S
ι : Type u_1
m : Basis ι R ↥M
H : Function.Injective ⇑(M.mulMap N)
⊢ M.LinearDisjoint N
state_after: no goals
tactic: exact ⟨H⟩
Theorem: CategoryTheory.CommSq.vert_inv
File: Mathlib/CategoryTheory/CommSq.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
W X Y Z : C
f : W ⟶ X
g✝ : W ⟶ Y
h✝ : X ⟶ Z
i : Y ⟶ Z
g : W ≅ Y
h : X ≅ Z
p : CommSq f g.hom h.hom i
⊢ i ≫ h.inv = g.inv ≫ f
state_after: no goals
tactic: rw [Iso.comp_inv_eq, Category.assoc, Iso.eq_inv_comp, p.w]
Theorem: MeasureTheory.Lp.eq_zero_iff_ae_eq_zero
File: Mathlib/MeasureTheory/Function/LpSpace.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : ↥(Lp E p μ)
⊢ f = 0 ↔ ↑↑f =ᶠ[ae μ] 0
state_after: no goals
tactic: rw [← (Lp.memℒp f).toLp_eq_toLp_iff zero_memℒp, Memℒp.toLp_zero, toLp_coeFn]
Theorem: Algebra.TensorProduct.productMap_left_apply
File: Mathlib/RingTheory/TensorProduct/Basic.lean

Proof steps:
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Semiring B
inst✝³ : CommSemiring S
inst✝² : Algebra R A
inst✝¹ : Algebra R B
inst✝ : Algebra R S
f : A →ₐ[R] S
g : B →ₐ[R] S
a : A
⊢ (productMap f g) (a ⊗ₜ[R] 1) = f a
state_after: no goals
tactic: simp
Theorem: CategoryTheory.IsPullback.id_horiz
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f✝ : X ⟶ Z
g : Y ⟶ Z
f : X ⟶ Z
⊢ 𝟙 X ≫ f = f ≫ 𝟙 Z
state_after: no goals
tactic: simp only [Category.id_comp, Category.comp_id]
Theorem: Vector3.insert_fs
File: Mathlib/Data/Vector3.lean

Proof steps:
state_before: α : Type u_1
m n : ℕ
a b : α
v : Vector3 α n
i : Fin2 (n + 1)
j : Fin2 (n + 1 + 1)
⊢ insert a (b :: v) i.fs j = (b :: insert a v i) j
state_after: case refine_2
α : Type u_1
m n : ℕ
a b : α
v : Vector3 α n
i : Fin2 (n + 1)
j✝ : Fin2 (n + 1 + 1)
j : Fin2 (n + 1)
⊢ (a :: b :: v)
      (match i.insertPerm j with
      | fz => fz
      | k.fs => k.fs.fs) =
    (a :: v) (i.insertPerm j)
tactic: refine j.cases' ?_ fun j => ?_ <;> simp [insert, insertPerm]
state_before: case refine_2
α : Type u_1
m n : ℕ
a b : α
v : Vector3 α n
i : Fin2 (n + 1)
j✝ : Fin2 (n + 1 + 1)
j : Fin2 (n + 1)
⊢ (a :: b :: v)
      (match i.insertPerm j with
      | fz => fz
      | k.fs => k.fs.fs) =
    (a :: v) (i.insertPerm j)
state_after: no goals
tactic: refine Fin2.cases' ?_ ?_ (insertPerm i j) <;> simp [insertPerm]
Theorem: HurwitzZeta.differentiableAt_hurwitzZetaEven
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

Proof steps:
state_before: a : UnitAddCircle
s : ℂ
hs' : s ≠ 1
⊢ DifferentiableAt ℂ (hurwitzZetaEven a) s
state_after: a : UnitAddCircle
s : ℂ
hs' : s ≠ 1
this :
  DifferentiableAt ℂ
    (Function.update (fun s => completedHurwitzZetaEven a s / s.Gammaℝ) 0 ((if a = 0 then -1 else 0) / 2)) s
⊢ DifferentiableAt ℂ (hurwitzZetaEven a) s
tactic: have := differentiableAt_update_of_residue
    (fun t ht ht' ↦ differentiableAt_completedHurwitzZetaEven a (Or.inl ht) ht')
    (completedHurwitzZetaEven_residue_zero a) s hs'
state_before: a : UnitAddCircle
s : ℂ
hs' : s ≠ 1
this :
  DifferentiableAt ℂ
    (Function.update (fun s => completedHurwitzZetaEven a s / s.Gammaℝ) 0 ((if a = 0 then -1 else 0) / 2)) s
⊢ DifferentiableAt ℂ (hurwitzZetaEven a) s
state_after: a : UnitAddCircle
s : ℂ
hs' : s ≠ 1
this :
  DifferentiableAt ℂ
    (Function.update (fun s => completedHurwitzZetaEven a s / s.Gammaℝ) 0 (if a = 0 then -1 / 2 else 0)) s
⊢ DifferentiableAt ℂ (hurwitzZetaEven a) s
tactic: simp_rw [div_eq_mul_inv, ite_mul, zero_mul, ← div_eq_mul_inv] at this
state_before: a : UnitAddCircle
s : ℂ
hs' : s ≠ 1
this :
  DifferentiableAt ℂ
    (Function.update (fun s => completedHurwitzZetaEven a s / s.Gammaℝ) 0 (if a = 0 then -1 / 2 else 0)) s
⊢ DifferentiableAt ℂ (hurwitzZetaEven a) s
state_after: no goals
tactic: exact this
Theorem: MeasureTheory.lintegral_liminf_le'
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
h_meas : ∀ (n : ℕ), AEMeasurable (f n) μ
⊢ ∫⁻ (a : α), liminf (fun n => f n a) atTop ∂μ = ∫⁻ (a : α), ⨆ n, ⨅ i, ⨅ (_ : i ≥ n), f i a ∂μ
state_after: no goals
tactic: simp only [liminf_eq_iSup_iInf_of_nat]
Theorem: generatePiSystem_measurableSet
File: Mathlib/MeasureTheory/PiSystem.lean

Proof steps:
state_before: α : Type u_1
M : MeasurableSpace α
S : Set (Set α)
h_meas_S : ∀ s ∈ S, MeasurableSet s
t : Set α
h_in_pi : t ∈ generatePiSystem S
⊢ MeasurableSet t
state_after: case base
α : Type u_1
M : MeasurableSpace α
S : Set (Set α)
h_meas_S : ∀ s ∈ S, MeasurableSet s
t s : Set α
h_s : s ∈ S
⊢ MeasurableSet s

case inter
α : Type u_1
M : MeasurableSpace α
S : Set (Set α)
h_meas_S : ∀ s ∈ S, MeasurableSet s
t s u : Set α
h_s✝ : generatePiSystem S s
h_t✝ : generatePiSystem S u
h_nonempty✝ : (s ∩ u).Nonempty
h_s : MeasurableSet s
h_u : MeasurableSet u
⊢ MeasurableSet (s ∩ u)
tactic: induction' h_in_pi with s h_s s u _ _ _ h_s h_u
Theorem: Equiv.piCongrLeft_symm_preimage_univ_pi
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
f : ι' ≃ ι
t : (i : ι) → Set (α i)
⊢ (⇑(piCongrLeft α f).symm ⁻¹' univ.pi fun i' => t (f i')) = univ.pi t
state_after: no goals
tactic: simpa [f.surjective.range_eq] using piCongrLeft_symm_preimage_pi f univ t
Theorem: Zsqrtd.add_le_add_left
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

Proof steps:
state_before: d : ℕ
a b : ℤ√↑d
ab : a ≤ b
c : ℤ√↑d
⊢ (c + b - (c + a)).Nonneg
state_after: d : ℕ
a b : ℤ√↑d
ab : a ≤ b
c : ℤ√↑d
⊢ (b - a).Nonneg
tactic: rw [add_sub_add_left_eq_sub]
state_before: d : ℕ
a b : ℤ√↑d
ab : a ≤ b
c : ℤ√↑d
⊢ (b - a).Nonneg
state_after: no goals
tactic: exact ab
Theorem: SimpleGraph.boxProd_adj_left
File: Mathlib/Combinatorics/SimpleGraph/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
G : SimpleGraph α
H : SimpleGraph β
a₁ : α
b : β
a₂ : α
⊢ (G □ H).Adj (a₁, b) (a₂, b) ↔ G.Adj a₁ a₂
state_after: no goals
tactic: simp only [boxProd_adj, and_true, SimpleGraph.irrefl, false_and, or_false]
Theorem: MonoidHom.noncommCoprod_unique
File: Mathlib/GroupTheory/NoncommCoprod.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : Monoid P
f✝ : M →* P
g : N →* P
comm : ∀ (m : M) (n : N), Commute (f✝ m) (g n)
f : M × N →* P
x : M × N
⊢ ((f.comp (inl M N)).noncommCoprod (f.comp (inr M N)) ⋯) x = f x
state_after: no goals
tactic: simp [coprod_apply, inl_apply, inr_apply, ← map_mul]
Theorem: Function.not_injective_iff
File: Mathlib/Logic/Function/Basic.lean

Proof steps:
state_before: α : Sort u_1
β : Sort u_2
γ : Sort u_3
f : α → β
⊢ ¬Injective f ↔ ∃ a b, f a = f b ∧ a ≠ b
state_after: no goals
tactic: simp only [Injective, not_forall, exists_prop]
Theorem: LinearIndependent.map'
File: Mathlib/LinearAlgebra/LinearIndependent.lean

Proof steps:
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
hv : LinearIndependent R v
f : M →ₗ[R] M'
hf_inj : LinearMap.ker f = ⊥
⊢ Disjoint (span R (range v)) (LinearMap.ker f)
state_after: no goals
tactic: simp [hf_inj]
Theorem: convexHull_neg
File: Mathlib/Analysis/Convex/Hull.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
⊢ (convexHull 𝕜) (-s) = -(convexHull 𝕜) s
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
⊢ (convexHull 𝕜) (Neg.neg '' s) = Neg.neg '' (convexHull 𝕜) s
tactic: simp_rw [← image_neg]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s : Set E
⊢ (convexHull 𝕜) (Neg.neg '' s) = Neg.neg '' (convexHull 𝕜) s
state_after: no goals
tactic: exact AffineMap.image_convexHull (-1) _ |>.symm
Theorem: ProbabilityTheory.condCount_eq_zero_iff
File: Mathlib/Probability/CondCount.lean

Proof steps:
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t u : Set Ω
hs : s.Finite
⊢ (condCount s) t = 0 ↔ s ∩ t = ∅
state_after: no goals
tactic: simp [condCount, cond_apply _ hs.measurableSet, Measure.count_apply_eq_top, Set.not_infinite.2 hs,
    Measure.count_apply_finite _ (hs.inter_of_left _)]
Theorem: MeasureTheory.integral_average_sub
File: Mathlib/MeasureTheory/Integral/Average.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ ν : Measure α
s t : Set α
f g : α → E
inst✝ : IsFiniteMeasure μ
hf : Integrable f μ
⊢ ∫ (x : α), ⨍ (a : α), f a ∂μ - f x ∂μ = 0
state_after: no goals
tactic: rw [integral_sub (integrable_const _) hf, integral_average, sub_self]
Theorem: IsAddFreimanHom.sub
File: Mathlib/Combinatorics/Additive/FreimanHom.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β✝ : Type u_3
γ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : DivisionCommMonoid β✝
A : Set α
B : Set β✝
f : α → β✝
m n : ℕ
β : Type u_5
inst✝ : DivisionCommMonoid β
B₁ B₂ : Set β
f₁ f₂ : α → β
h₁ : IsMulFreimanHom n A B₁ f₁
h₂ : IsMulFreimanHom n A B₂ f₂
s t : Multiset α
hsA : ∀ ⦃x : α⦄, x ∈ s → x ∈ A
htA : ∀ ⦃x : α⦄, x ∈ t → x ∈ A
hs : card s = n
ht : card t = n
h : s.prod = t.prod
⊢ (map (f₁ / f₂) s).prod = (map (f₁ / f₂) t).prod
state_after: no goals
tactic: rw [Pi.div_def, prod_map_div, prod_map_div, h₁.map_prod_eq_map_prod hsA htA hs ht h,
      h₂.map_prod_eq_map_prod hsA htA hs ht h]
Theorem: List.Nodup.getEquiv_symm_apply_val
File: Mathlib/Data/List/NodupEquivFin.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
H : l.Nodup
i : Fin l.length
⊢ (fun x => ⟨indexOf (↑x) l, ⋯⟩) ((fun i => ⟨l.get i, ⋯⟩) i) = i
state_after: no goals
tactic: simp only [List.get_indexOf, eq_self_iff_true, Fin.eta, Subtype.coe_mk, H]
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
H : l.Nodup
x : { x // x ∈ l }
⊢ (fun i => ⟨l.get i, ⋯⟩) ((fun x => ⟨indexOf (↑x) l, ⋯⟩) x) = x
state_after: no goals
tactic: simp
Theorem: Real.logb_div
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

Proof steps:
state_before: b x y : ℝ
hx : x ≠ 0
hy : y ≠ 0
⊢ logb b (x / y) = logb b x - logb b y
state_after: no goals
tactic: simp_rw [logb, log_div hx hy, sub_div]
Theorem: CategoryTheory.Square.opFunctor_map_τ₁
File: Mathlib/CategoryTheory/Square.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : (Square C)ᵒᵖ
φ : X✝ ⟶ Y✝
⊢ (((fun sq => (Opposite.unop sq).op) X✝).f₁₂ ≫ φ.unop.τ₂.op).unop =
    (φ.unop.τ₄.op ≫ ((fun sq => (Opposite.unop sq).op) Y✝).f₁₂).unop
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : (Square C)ᵒᵖ
φ : X✝ ⟶ Y✝
⊢ (((fun sq => (Opposite.unop sq).op) X✝).f₁₃ ≫ φ.unop.τ₃.op).unop =
    (φ.unop.τ₄.op ≫ ((fun sq => (Opposite.unop sq).op) Y✝).f₁₃).unop
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : (Square C)ᵒᵖ
φ : X✝ ⟶ Y✝
⊢ (((fun sq => (Opposite.unop sq).op) X✝).f₂₄ ≫ φ.unop.τ₁.op).unop =
    (φ.unop.τ₂.op ≫ ((fun sq => (Opposite.unop sq).op) Y✝).f₂₄).unop
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : (Square C)ᵒᵖ
φ : X✝ ⟶ Y✝
⊢ (((fun sq => (Opposite.unop sq).op) X✝).f₃₄ ≫ φ.unop.τ₁.op).unop =
    (φ.unop.τ₃.op ≫ ((fun sq => (Opposite.unop sq).op) Y✝).f₃₄).unop
state_after: no goals
tactic: simp
Theorem: Computation.map_parallel
File: Mathlib/Data/Seq/Parallel.lean

Proof steps:
state_before: α : Type u
β : Type v
f : α → β
S : WSeq (Computation α)
⊢ map f (parallel S) = parallel (WSeq.map (map f) S)
state_after: α : Type u
β : Type v
f : α → β
S : WSeq (Computation α)
⊢ IsBisimulation fun c1 c2 =>
    ∃ l S, c1 = map f (corec parallel.aux1 (l, S)) ∧ c2 = corec parallel.aux1 (List.map (map f) l, WSeq.map (map f) S)
tactic: refine
    eq_of_bisim
      (fun c1 c2 =>
        ∃ l S,
          c1 = map f (corec parallel.aux1 (l, S)) ∧
            c2 = corec parallel.aux1 (l.map (map f), S.map (map f)))
      ?_ ⟨[], S, rfl, rfl⟩
state_before: α : Type u
β : Type v
f : α → β
S : WSeq (Computation α)
⊢ IsBisimulation fun c1 c2 =>
    ∃ l S, c1 = map f (corec parallel.aux1 (l, S)) ∧ c2 = corec parallel.aux1 (List.map (map f) l, WSeq.map (map f) S)
state_after: α : Type u
β : Type v
f : α → β
S : WSeq (Computation α)
c1 c2 : Computation β
h : ∃ l S, c1 = map f (corec parallel.aux1 (l, S)) ∧ c2 = corec parallel.aux1 (List.map (map f) l, WSeq.map (map f) S)
⊢ BisimO
    (fun c1 c2 =>
      ∃ l S,
        c1 = map f (corec parallel.aux1 (l, S)) ∧ c2 = corec parallel.aux1 (List.map (map f) l, WSeq.map (map f) S))
    c1.destruct c2.destruct
tactic: intro c1 c2 h
Theorem: HomologicalComplex.biprod_inl_desc_f
File: Mathlib/Algebra/Homology/HomologicalComplexBiprod.lean

Proof steps:
state_before: C : Type u_1
ι : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Preadditive C
c : ComplexShape ι
K L : HomologicalComplex C c
inst✝ : ∀ (i : ι), HasBinaryBiproduct (K.X i) (L.X i)
M : HomologicalComplex C c
α : K ⟶ M
β : L ⟶ M
i : ι
⊢ biprod.inl.f i ≫ (biprod.desc α β).f i = α.f i
state_after: no goals
tactic: rw [← comp_f, biprod.inl_desc]
Theorem: Filter.Eventually.atTop_of_arithmetic
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
p : ℕ → Prop
n : ℕ
hn : n ≠ 0
hp : ∀ k < n, ∀ᶠ (a : ℕ) in atTop, p (n * a + k)
⊢ ∀ᶠ (a : ℕ) in atTop, p a
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
p : ℕ → Prop
n : ℕ
hn : n ≠ 0
hp : ∀ k < n, ∃ a, ∀ b ≥ a, p (n * b + k)
⊢ ∃ a, ∀ b ≥ a, p b
tactic: simp only [eventually_atTop] at hp ⊢
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
p : ℕ → Prop
n : ℕ
hn : n ≠ 0
hp : ∀ k < n, ∃ a, ∀ b ≥ a, p (n * b + k)
⊢ ∃ a, ∀ b ≥ a, p b
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
p : ℕ → Prop
n : ℕ
hn : n ≠ 0
N : ℕ → ℕ
hN : ∀ k < n, ∀ b ≥ N k, p (n * b + k)
⊢ ∃ a, ∀ b ≥ a, p b
tactic: choose! N hN using hp
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
p : ℕ → Prop
n : ℕ
hn : n ≠ 0
N : ℕ → ℕ
hN : ∀ k < n, ∀ b ≥ N k, p (n * b + k)
b : ℕ
hb : b ≥ (Finset.range n).sup fun x => n * N x
⊢ p b
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
p : ℕ → Prop
n : ℕ
hn : n ≠ 0
N : ℕ → ℕ
hN : ∀ k < n, ∀ b ≥ N k, p (n * b + k)
b : ℕ
hb : b ≥ (Finset.range n).sup fun x => n * N x
⊢ p (n * (b / n) + b % n)
tactic: rw [← Nat.div_add_mod b n]
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
p : ℕ → Prop
n : ℕ
hn : n ≠ 0
N : ℕ → ℕ
hN : ∀ k < n, ∀ b ≥ N k, p (n * b + k)
b : ℕ
hb : b ≥ (Finset.range n).sup fun x => n * N x
⊢ p (n * (b / n) + b % n)
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
p : ℕ → Prop
n : ℕ
hn : n ≠ 0
N : ℕ → ℕ
hN : ∀ k < n, ∀ b ≥ N k, p (n * b + k)
b : ℕ
hb : b ≥ (Finset.range n).sup fun x => n * N x
hlt : b % n < n
⊢ p (n * (b / n) + b % n)
tactic: have hlt := Nat.mod_lt b hn.bot_lt
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
p : ℕ → Prop
n : ℕ
hn : n ≠ 0
N : ℕ → ℕ
hN : ∀ k < n, ∀ b ≥ N k, p (n * b + k)
b : ℕ
hb : b ≥ (Finset.range n).sup fun x => n * N x
hlt : b % n < n
⊢ p (n * (b / n) + b % n)
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
p : ℕ → Prop
n : ℕ
hn : n ≠ 0
N : ℕ → ℕ
hN : ∀ k < n, ∀ b ≥ N k, p (n * b + k)
b : ℕ
hb : b ≥ (Finset.range n).sup fun x => n * N x
hlt : b % n < n
⊢ b / n ≥ N (b % n)
tactic: refine hN _ hlt _ ?_
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
p : ℕ → Prop
n : ℕ
hn : n ≠ 0
N : ℕ → ℕ
hN : ∀ k < n, ∀ b ≥ N k, p (n * b + k)
b : ℕ
hb : b ≥ (Finset.range n).sup fun x => n * N x
hlt : b % n < n
⊢ b / n ≥ N (b % n)
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
p : ℕ → Prop
n : ℕ
hn : n ≠ 0
N : ℕ → ℕ
hN : ∀ k < n, ∀ b ≥ N k, p (n * b + k)
b : ℕ
hb : b ≥ (Finset.range n).sup fun x => n * N x
hlt : b % n < n
⊢ n * N (b % n) ≤ b
tactic: rw [ge_iff_le, Nat.le_div_iff_mul_le hn.bot_lt, mul_comm]
Theorem: CategoryTheory.IsHomLift.id_lift_eqToHom_codomain
File: Mathlib/CategoryTheory/FiberedCategory/HomLift.lean

Proof steps:
state_before: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p✝ p : 𝒳 ⥤ 𝒮
R S : 𝒮
hRS : R = S
b : 𝒳
hb : p.obj b = S
⊢ p.IsHomLift (eqToHom hRS) (𝟙 b)
state_after: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p✝ p : 𝒳 ⥤ 𝒮
b : 𝒳
⊢ p.IsHomLift (eqToHom ⋯) (𝟙 b)
tactic: subst hRS hb
state_before: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p✝ p : 𝒳 ⥤ 𝒮
b : 𝒳
⊢ p.IsHomLift (eqToHom ⋯) (𝟙 b)
state_after: no goals
tactic: simp
Theorem: LinearMap.iInf_ker_proj_le_iSup_range_stdBasis
File: Mathlib/LinearAlgebra/StdBasis.lean

Proof steps:
state_before: R : Type u_1
ι : Type u_2
inst✝³ : Semiring R
φ : ι → Type u_3
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
I : Finset ι
J : Set ι
hu : univ ⊆ ↑I ∪ J
⊢ ∀ ⦃x : (i : ι) → φ i⦄, x ∈ ⨅ i ∈ J, ker (proj i) → x ∈ ⨆ i ∈ I, range (stdBasis R φ i)
state_after: R : Type u_1
ι : Type u_2
inst✝³ : Semiring R
φ : ι → Type u_3
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
I : Finset ι
J : Set ι
hu : univ ⊆ ↑I ∪ J
b : (i : ι) → φ i
hb : b ∈ ⨅ i ∈ J, ker (proj i)
⊢ b ∈ ⨆ i ∈ I, range (stdBasis R φ i)
tactic: intro b hb
state_before: R : Type u_1
ι : Type u_2
inst✝³ : Semiring R
φ : ι → Type u_3
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
I : Finset ι
J : Set ι
hu : univ ⊆ ↑I ∪ J
b : (i : ι) → φ i
hb : b ∈ ⨅ i ∈ J, ker (proj i)
⊢ b ∈ ⨆ i ∈ I, range (stdBasis R φ i)
state_after: R : Type u_1
ι : Type u_2
inst✝³ : Semiring R
φ : ι → Type u_3
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
I : Finset ι
J : Set ι
hu : univ ⊆ ↑I ∪ J
b : (i : ι) → φ i
hb : ∀ i ∈ J, b i = 0
⊢ b ∈ ⨆ i ∈ I, range (stdBasis R φ i)
tactic: simp only [mem_iInf, mem_ker, proj_apply] at hb
state_before: R : Type u_1
ι : Type u_2
inst✝³ : Semiring R
φ : ι → Type u_3
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
I : Finset ι
J : Set ι
hu : univ ⊆ ↑I ∪ J
b : (i : ι) → φ i
hb : ∀ i ∈ J, b i = 0
⊢ b ∈ ⨆ i ∈ I, range (stdBasis R φ i)
state_after: R : Type u_1
ι : Type u_2
inst✝³ : Semiring R
φ : ι → Type u_3
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
I : Finset ι
J : Set ι
hu : univ ⊆ ↑I ∪ J
b : (i : ι) → φ i
hb : ∀ i ∈ J, b i = 0
⊢ ∑ i ∈ I, (stdBasis R φ i) (b i) ∈ ⨆ i ∈ I, range (stdBasis R φ i)
tactic: rw [←
        show (∑ i ∈ I, stdBasis R φ i (b i)) = b by
          ext i
          rw [Finset.sum_apply, ← stdBasis_same R φ i (b i)]
          refine Finset.sum_eq_single i (fun j _ ne => stdBasis_ne _ _ _ _ ne.symm _) ?_
          intro hiI
          rw [stdBasis_same]
          exact hb _ ((hu trivial).resolve_left hiI)]
state_before: R : Type u_1
ι : Type u_2
inst✝³ : Semiring R
φ : ι → Type u_3
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
I : Finset ι
J : Set ι
hu : univ ⊆ ↑I ∪ J
b : (i : ι) → φ i
hb : ∀ i ∈ J, b i = 0
⊢ ∑ i ∈ I, (stdBasis R φ i) (b i) ∈ ⨆ i ∈ I, range (stdBasis R φ i)
state_after: no goals
tactic: exact sum_mem_biSup fun i _ => mem_range_self (stdBasis R φ i) (b i)
Theorem: UniformInducing.of_comp_iff
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
g : β → γ
hg : UniformInducing g
f : α → β
⊢ UniformInducing (g ∘ f) ↔ UniformInducing f
state_after: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
g : β → γ
hg : UniformInducing g
f : α → β
h : UniformInducing (g ∘ f)
⊢ UniformInducing f
tactic: refine ⟨fun h ↦ ?_, hg.comp⟩
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
g : β → γ
hg : UniformInducing g
f : α → β
h : UniformInducing (g ∘ f)
⊢ UniformInducing f
state_after: no goals
tactic: rw [uniformInducing_iff, ← hg.comap_uniformity, comap_comap, ← h.comap_uniformity,
    Function.comp, Function.comp]