ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.Adapted.isStoppingTime_crossing
File: Mathlib/Probability/Martingale/Upcrossing.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
hf : Adapted ℱ f
⊢ IsStoppingTime ℱ (upperCrossingTime a b f N n) ∧ IsStoppingTime ℱ (lowerCrossingTime a b f N n)
state_after: case zero
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
hf : Adapted ℱ f
⊢ IsStoppingTime ℱ (upperCrossingTime a b f N 0) ∧ IsStoppingTime ℱ (lowerCrossingTime a b f N 0)

case succ
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
hf : Adapted ℱ f
k : ℕ
ih : IsStoppingTime ℱ (upperCrossingTime a b f N k) ∧ IsStoppingTime ℱ (lowerCrossingTime a b f N k)
⊢ IsStoppingTime ℱ (upperCrossingTime a b f N (k + 1)) ∧ IsStoppingTime ℱ (lowerCrossingTime a b f N (k + 1))
tactic: induction' n with k ih
Theorem: ProbabilityTheory.setIntegral_compProd
File: Mathlib/Probability/Kernel/IntegralCompProd.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
E : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝⁶ : NormedAddCommGroup E
κ : Kernel α β
inst✝⁵ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝⁴ : IsSFiniteKernel η
a : α
inst✝³ : NormedSpace ℝ E
E' : Type u_5
inst✝² : NormedAddCommGroup E'
inst✝¹ : CompleteSpace E'
inst✝ : NormedSpace ℝ E'
f : β × γ → E
s : Set β
t : Set γ
hs : MeasurableSet s
ht : MeasurableSet t
hf : IntegrableOn f (s ×ˢ t) ((κ ⊗ₖ η) a)
⊢ ∫ (z : β × γ) in s ×ˢ t, f z ∂(κ ⊗ₖ η) a = ∫ (x : β) in s, ∫ (y : γ) in t, f (x, y) ∂η (a, x) ∂κ a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
E : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝⁶ : NormedAddCommGroup E
κ : Kernel α β
inst✝⁵ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝⁴ : IsSFiniteKernel η
a : α
inst✝³ : NormedSpace ℝ E
E' : Type u_5
inst✝² : NormedAddCommGroup E'
inst✝¹ : CompleteSpace E'
inst✝ : NormedSpace ℝ E'
f : β × γ → E
s : Set β
t : Set γ
hs : MeasurableSet s
ht : MeasurableSet t
hf : IntegrableOn f (s ×ˢ t) ((κ ⊗ₖ η) a)
⊢ ∫ (x : β), ∫ (y : γ), f (x, y) ∂(η.restrict ht) (a, x) ∂(κ.restrict hs) a =
    ∫ (x : β) in s, ∫ (y : γ) in t, f (x, y) ∂η (a, x) ∂κ a

α : Type u_1
β : Type u_2
γ : Type u_3
E : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝⁶ : NormedAddCommGroup E
κ : Kernel α β
inst✝⁵ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝⁴ : IsSFiniteKernel η
a : α
inst✝³ : NormedSpace ℝ E
E' : Type u_5
inst✝² : NormedAddCommGroup E'
inst✝¹ : CompleteSpace E'
inst✝ : NormedSpace ℝ E'
f : β × γ → E
s : Set β
t : Set γ
hs : MeasurableSet s
ht : MeasurableSet t
hf : IntegrableOn f (s ×ˢ t) ((κ ⊗ₖ η) a)
⊢ Integrable f ((κ.restrict hs ⊗ₖ η.restrict ht) a)
tactic: rw [← Kernel.restrict_apply (κ ⊗ₖ η) (hs.prod ht), ← compProd_restrict hs ht, integral_compProd]
Theorem: CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso_inv_app_hom₃
File: Mathlib/CategoryTheory/Triangulated/Opposite.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.192952, u_1} C
inst✝ : HasShift C ℤ
T : Triangle Cᵒᵖ
⊢ (inverse C ⋙ functor C).obj T ≅ (𝟭 (Triangle Cᵒᵖ)).obj T
state_after: case refine_1
C : Type u_1
inst✝¹ : Category.{?u.192952, u_1} C
inst✝ : HasShift C ℤ
T : Triangle Cᵒᵖ
⊢ ((inverse C ⋙ functor C).obj T).mor₁ ≫ (Iso.refl ((inverse C ⋙ functor C).obj T).obj₂).hom =
    (Iso.refl ((inverse C ⋙ functor C).obj T).obj₁).hom ≫ ((𝟭 (Triangle Cᵒᵖ)).obj T).mor₁

case refine_2
C : Type u_1
inst✝¹ : Category.{?u.192952, u_1} C
inst✝ : HasShift C ℤ
T : Triangle Cᵒᵖ
⊢ ((inverse C ⋙ functor C).obj T).mor₂ ≫ (Iso.refl ((inverse C ⋙ functor C).obj T).obj₃).hom =
    (Iso.refl ((inverse C ⋙ functor C).obj T).obj₂).hom ≫ ((𝟭 (Triangle Cᵒᵖ)).obj T).mor₂

case refine_3
C : Type u_1
inst✝¹ : Category.{?u.192952, u_1} C
inst✝ : HasShift C ℤ
T : Triangle Cᵒᵖ
⊢ ((inverse C ⋙ functor C).obj T).mor₃ ≫ (shiftFunctor Cᵒᵖ 1).map (Iso.refl ((inverse C ⋙ functor C).obj T).obj₁).hom =
    (Iso.refl ((inverse C ⋙ functor C).obj T).obj₃).hom ≫ ((𝟭 (Triangle Cᵒᵖ)).obj T).mor₃
tactic: refine Triangle.isoMk _ _ (Iso.refl _) (Iso.refl _) (Iso.refl _) ?_ ?_ ?_
state_before: C : Type u_1
inst✝¹ : Category.{?u.192952, u_1} C
inst✝ : HasShift C ℤ
⊢ ∀ {X Y : Triangle Cᵒᵖ} (f : X ⟶ Y),
    (inverse C ⋙ functor C).map f ≫
        ((fun T =>
              ((inverse C ⋙ functor C).obj T).isoMk ((𝟭 (Triangle Cᵒᵖ)).obj T)
                (Iso.refl ((inverse C ⋙ functor C).obj T).obj₁) (Iso.refl ((inverse C ⋙ functor C).obj T).obj₂)
                (Iso.refl ((inverse C ⋙ functor C).obj T).obj₃) ⋯ ⋯ ⋯)
            Y).hom =
      ((fun T =>
              ((inverse C ⋙ functor C).obj T).isoMk ((𝟭 (Triangle Cᵒᵖ)).obj T)
                (Iso.refl ((inverse C ⋙ functor C).obj T).obj₁) (Iso.refl ((inverse C ⋙ functor C).obj T).obj₂)
                (Iso.refl ((inverse C ⋙ functor C).obj T).obj₃) ⋯ ⋯ ⋯)
            X).hom ≫
        (𝟭 (Triangle Cᵒᵖ)).map f
state_after: no goals
tactic: aesop_cat
Theorem: Subalgebra.toSubring_injective
File: Mathlib/Algebra/Algebra/Subalgebra/Basic.lean

Proof steps:
state_before: R' : Type u'
R✝ : Type u
A✝ : Type v
B : Type w
C : Type w'
inst✝⁹ : CommSemiring R✝
inst✝⁸ : Semiring A✝
inst✝⁷ : Algebra R✝ A✝
inst✝⁶ : Semiring B
inst✝⁵ : Algebra R✝ B
inst✝⁴ : Semiring C
inst✝³ : Algebra R✝ C
S✝ : Subalgebra R✝ A✝
R : Type u
A : Type v
inst✝² : CommRing R
inst✝¹ : Ring A
inst✝ : Algebra R A
S T : Subalgebra R A
h : S.toSubring = T.toSubring
x : A
⊢ x ∈ S ↔ x ∈ T
state_after: no goals
tactic: rw [← mem_toSubring, ← mem_toSubring, h]
Theorem: Primrec.list_length
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
l : List α
⊢ List.foldr (fun b s => (fun a b => (a, b).2.2.succ) (l, b, s).1 (l, b, s).2) 0 (id l) = l.length
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
l : List α
⊢ List.foldr (fun b s => s + 1) 0 l = l.length
tactic: dsimp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
l : List α
⊢ List.foldr (fun b s => s + 1) 0 l = l.length
state_after: no goals
tactic: induction l <;> simp [*]
Theorem: CategoryTheory.PreGaloisCategory.card_aut_le_card_fiber_of_connected
File: Mathlib/CategoryTheory/Galois/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsConnected A
⊢ Nat.card (Aut A) ≤ Nat.card ↑(F.obj A)
state_after: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsConnected A
h : Nonempty ↑(F.obj A)
⊢ Nat.card (Aut A) ≤ Nat.card ↑(F.obj A)
tactic: have h : Nonempty (F.obj A) := inferInstance
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsConnected A
h : Nonempty ↑(F.obj A)
⊢ Nat.card (Aut A) ≤ Nat.card ↑(F.obj A)
state_after: case intro
C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsConnected A
a : ↑(F.obj A)
⊢ Nat.card (Aut A) ≤ Nat.card ↑(F.obj A)
tactic: obtain ⟨a⟩ := h
state_before: case intro
C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsConnected A
a : ↑(F.obj A)
⊢ Nat.card (Aut A) ≤ Nat.card ↑(F.obj A)
state_after: case intro.hf
C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsConnected A
a : ↑(F.obj A)
⊢ Function.Injective ?intro.f

case intro.f
C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsConnected A
a : ↑(F.obj A)
⊢ Aut A → ↑(F.obj A)
tactic: apply Nat.card_le_card_of_injective
state_before: case intro.hf
C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsConnected A
a : ↑(F.obj A)
⊢ Function.Injective ?intro.f

case intro.f
C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsConnected A
a : ↑(F.obj A)
⊢ Aut A → ↑(F.obj A)
state_after: no goals
tactic: exact evaluation_aut_injective_of_isConnected _ _ a
Theorem: Polynomial.coe_normUnit
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizationMonoid R
p : R[X]
⊢ ↑(normUnit p) = C ↑(normUnit p.leadingCoeff)
state_after: no goals
tactic: simp [normUnit]
Theorem: continuousOn_Icc_extendFrom_Ioo
File: Mathlib/Topology/Order/ExtendFrom.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : TopologicalSpace α
inst✝⁴ : LinearOrder α
inst✝³ : DenselyOrdered α
inst✝² : OrderTopology α
inst✝¹ : TopologicalSpace β
inst✝ : RegularSpace β
f : α → β
a b : α
la lb : β
hab : a ≠ b
hf : ContinuousOn f (Ioo a b)
ha : Tendsto f (𝓝[>] a) (𝓝 la)
hb : Tendsto f (𝓝[<] b) (𝓝 lb)
⊢ ContinuousOn (extendFrom (Ioo a b) f) (Icc a b)
state_after: case hB
α : Type u_1
β : Type u_2
inst✝⁵ : TopologicalSpace α
inst✝⁴ : LinearOrder α
inst✝³ : DenselyOrdered α
inst✝² : OrderTopology α
inst✝¹ : TopologicalSpace β
inst✝ : RegularSpace β
f : α → β
a b : α
la lb : β
hab : a ≠ b
hf : ContinuousOn f (Ioo a b)
ha : Tendsto f (𝓝[>] a) (𝓝 la)
hb : Tendsto f (𝓝[<] b) (𝓝 lb)
⊢ Icc a b ⊆ closure (Ioo a b)

case hf
α : Type u_1
β : Type u_2
inst✝⁵ : TopologicalSpace α
inst✝⁴ : LinearOrder α
inst✝³ : DenselyOrdered α
inst✝² : OrderTopology α
inst✝¹ : TopologicalSpace β
inst✝ : RegularSpace β
f : α → β
a b : α
la lb : β
hab : a ≠ b
hf : ContinuousOn f (Ioo a b)
ha : Tendsto f (𝓝[>] a) (𝓝 la)
hb : Tendsto f (𝓝[<] b) (𝓝 lb)
⊢ ∀ x ∈ Icc a b, ∃ y, Tendsto f (𝓝[Ioo a b] x) (𝓝 y)
tactic: apply continuousOn_extendFrom
Theorem: ZMod.inv_coe_unit
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n✝ n : ℕ
u : (ZMod n)ˣ
⊢ (↑u)⁻¹ = ↑u⁻¹
state_after: m n✝ n : ℕ
u : (ZMod n)ˣ
this : ↑((↑u).val.gcd n) = ↑1
⊢ (↑u)⁻¹ = ↑u⁻¹
tactic: have := congr_arg ((↑) : ℕ → ZMod n) (val_coe_unit_coprime u)
state_before: m n✝ n : ℕ
u : (ZMod n)ˣ
this : ↑((↑u).val.gcd n) = ↑1
⊢ (↑u)⁻¹ = ↑u⁻¹
state_after: m n✝ n : ℕ
u : (ZMod n)ˣ
this : ↑u * (↑u)⁻¹ = 1
⊢ (↑u)⁻¹ = ↑u⁻¹
tactic: rw [← mul_inv_eq_gcd, Nat.cast_one] at this
state_before: m n✝ n : ℕ
u : (ZMod n)ˣ
this : ↑u * (↑u)⁻¹ = 1
⊢ (↑u)⁻¹ = ↑u⁻¹
state_after: m n✝ n : ℕ
u : (ZMod n)ˣ
this : ↑u * (↑u)⁻¹ = 1
u' : (ZMod n)ˣ := { val := ↑u, inv := (↑u)⁻¹, val_inv := this, inv_val := ⋯ }
⊢ (↑u)⁻¹ = ↑u⁻¹
tactic: let u' : (ZMod n)ˣ := ⟨u, (u : ZMod n)⁻¹, this, by rwa [mul_comm]⟩
state_before: m n✝ n : ℕ
u : (ZMod n)ˣ
this : ↑u * (↑u)⁻¹ = 1
u' : (ZMod n)ˣ := { val := ↑u, inv := (↑u)⁻¹, val_inv := this, inv_val := ⋯ }
⊢ (↑u)⁻¹ = ↑u⁻¹
state_after: m n✝ n : ℕ
u : (ZMod n)ˣ
this : ↑u * (↑u)⁻¹ = 1
u' : (ZMod n)ˣ := { val := ↑u, inv := (↑u)⁻¹, val_inv := this, inv_val := ⋯ }
h : u = u'
⊢ (↑u)⁻¹ = ↑u⁻¹
tactic: have h : u = u' := by
    apply Units.ext
    rfl
state_before: m n✝ n : ℕ
u : (ZMod n)ˣ
this : ↑u * (↑u)⁻¹ = 1
u' : (ZMod n)ˣ := { val := ↑u, inv := (↑u)⁻¹, val_inv := this, inv_val := ⋯ }
h : u = u'
⊢ (↑u)⁻¹ = ↑u⁻¹
state_after: m n✝ n : ℕ
u : (ZMod n)ˣ
this : ↑u * (↑u)⁻¹ = 1
u' : (ZMod n)ˣ := { val := ↑u, inv := (↑u)⁻¹, val_inv := this, inv_val := ⋯ }
h : u = u'
⊢ (↑u')⁻¹ = ↑u'⁻¹
tactic: rw [h]
state_before: m n✝ n : ℕ
u : (ZMod n)ˣ
this : ↑u * (↑u)⁻¹ = 1
u' : (ZMod n)ˣ := { val := ↑u, inv := (↑u)⁻¹, val_inv := this, inv_val := ⋯ }
h : u = u'
⊢ (↑u')⁻¹ = ↑u'⁻¹
state_after: no goals
tactic: rfl
Theorem: PolynomialModule.monomial_smul_single
File: Mathlib/Algebra/Polynomial/Module/Basic.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
I : Ideal R
S : Type u_3
inst✝³ : CommSemiring S
inst✝² : Algebra S R
inst✝¹ : Module S M
inst✝ : IsScalarTower S R M
i : ℕ
r : R
j : ℕ
m : M
⊢ (monomial i) r • (single R j) m = (single R (i + j)) (r • m)
state_after: R : Type u_1
M : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
I : Ideal R
S : Type u_3
inst✝³ : CommSemiring S
inst✝² : Algebra S R
inst✝¹ : Module S M
inst✝ : IsScalarTower S R M
i : ℕ
r : R
j : ℕ
m : M
⊢ r • (⇑(Finsupp.lmapDomain M R Nat.succ))^[i] ((single R j) m) = (single R (i + j)) (r • m)
tactic: simp only [LinearMap.mul_apply, Polynomial.aeval_monomial, LinearMap.pow_apply,
    Module.algebraMap_end_apply, smul_def]
state_before: R : Type u_1
M : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
I : Ideal R
S : Type u_3
inst✝³ : CommSemiring S
inst✝² : Algebra S R
inst✝¹ : Module S M
inst✝ : IsScalarTower S R M
i : ℕ
r : R
j : ℕ
m : M
⊢ r • (⇑(Finsupp.lmapDomain M R Nat.succ))^[i] ((single R j) m) = (single R (i + j)) (r • m)
state_after: no goals
tactic: induction i generalizing r j m with
  | zero =>
    rw [Function.iterate_zero, zero_add]
    exact Finsupp.smul_single r j m
  | succ n hn =>
    rw [Function.iterate_succ, Function.comp_apply, add_assoc, ← hn]
    congr 2
    rw [Nat.one_add]
    exact Finsupp.mapDomain_single
Theorem: IsSelfAdjoint.neg
File: Mathlib/Algebra/Star/SelfAdjoint.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝¹ : AddGroup R
inst✝ : StarAddMonoid R
x : R
hx : IsSelfAdjoint x
⊢ IsSelfAdjoint (-x)
state_after: no goals
tactic: simp only [isSelfAdjoint_iff, star_neg, hx.star_eq]
Theorem: Path.Homotopy.map_toFun
File: Mathlib/Topology/Homotopy/Path.lean

Proof steps:
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p q : Path x₀ x₁
F : p.Homotopy q
f : C(X, Y)
⊢ ∀ (x : ↑I), { toFun := ⇑f ∘ ⇑F, continuous_toFun := ⋯ }.toFun (0, x) = (p.map ⋯).toContinuousMap x
state_after: no goals
tactic: simp
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p q : Path x₀ x₁
F : p.Homotopy q
f : C(X, Y)
⊢ ∀ (x : ↑I), { toFun := ⇑f ∘ ⇑F, continuous_toFun := ⋯ }.toFun (1, x) = (q.map ⋯).toContinuousMap x
state_after: no goals
tactic: simp
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p q : Path x₀ x₁
F : p.Homotopy q
f : C(X, Y)
t x : ↑I
hx : x ∈ {0, 1}
⊢ { toFun := fun x => { toFun := ⇑f ∘ ⇑F, continuous_toFun := ⋯, map_zero_left := ⋯, map_one_left := ⋯ }.toFun (t, x),
        continuous_toFun := ⋯ }
      x =
    (p.map ⋯).toContinuousMap x
state_after: case inl
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p q : Path x₀ x₁
F : p.Homotopy q
f : C(X, Y)
t x : ↑I
hx : x = 0
⊢ { toFun := fun x => { toFun := ⇑f ∘ ⇑F, continuous_toFun := ⋯, map_zero_left := ⋯, map_one_left := ⋯ }.toFun (t, x),
        continuous_toFun := ⋯ }
      x =
    (p.map ⋯).toContinuousMap x

case inr
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p q : Path x₀ x₁
F : p.Homotopy q
f : C(X, Y)
t x : ↑I
hx : x ∈ {1}
⊢ { toFun := fun x => { toFun := ⇑f ∘ ⇑F, continuous_toFun := ⋯, map_zero_left := ⋯, map_one_left := ⋯ }.toFun (t, x),
        continuous_toFun := ⋯ }
      x =
    (p.map ⋯).toContinuousMap x
tactic: cases' hx with hx hx
Theorem: algebraMap_injective
File: Mathlib/NumberTheory/FunctionField.lean

Proof steps:
state_before: Fq F : Type
inst✝⁴ : Field Fq
inst✝³ : Field F
inst✝² : Algebra Fq[X] F
inst✝¹ : Algebra (RatFunc Fq) F
inst✝ : IsScalarTower Fq[X] (RatFunc Fq) F
⊢ Function.Injective ⇑(algebraMap Fq[X] F)
state_after: Fq F : Type
inst✝⁴ : Field Fq
inst✝³ : Field F
inst✝² : Algebra Fq[X] F
inst✝¹ : Algebra (RatFunc Fq) F
inst✝ : IsScalarTower Fq[X] (RatFunc Fq) F
⊢ Function.Injective ⇑((algebraMap (RatFunc Fq) F).comp (algebraMap Fq[X] (RatFunc Fq)))
tactic: rw [IsScalarTower.algebraMap_eq Fq[X] (RatFunc Fq) F]
state_before: Fq F : Type
inst✝⁴ : Field Fq
inst✝³ : Field F
inst✝² : Algebra Fq[X] F
inst✝¹ : Algebra (RatFunc Fq) F
inst✝ : IsScalarTower Fq[X] (RatFunc Fq) F
⊢ Function.Injective ⇑((algebraMap (RatFunc Fq) F).comp (algebraMap Fq[X] (RatFunc Fq)))
state_after: no goals
tactic: exact (algebraMap (RatFunc Fq) F).injective.comp (IsFractionRing.injective Fq[X] (RatFunc Fq))
Theorem: CategoryTheory.ShortComplex.Exact.map
File: Mathlib/Algebra/Homology/ShortComplex/Exact.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁶ : Category.{u_3, u_1} C
inst✝⁵ : Category.{u_4, u_2} D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
h : S.Exact
F : C ⥤ D
inst✝² : F.PreservesZeroMorphisms
inst✝¹ : F.PreservesLeftHomologyOf S
inst✝ : F.PreservesRightHomologyOf S
⊢ (S.map F).Exact
state_after: C : Type u_1
D : Type u_2
inst✝⁶ : Category.{u_3, u_1} C
inst✝⁵ : Category.{u_4, u_2} D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
h : S.Exact
F : C ⥤ D
inst✝² : F.PreservesZeroMorphisms
inst✝¹ : F.PreservesLeftHomologyOf S
inst✝ : F.PreservesRightHomologyOf S
this : S.HasHomology
⊢ (S.map F).Exact
tactic: have := h.hasHomology
state_before: C : Type u_1
D : Type u_2
inst✝⁶ : Category.{u_3, u_1} C
inst✝⁵ : Category.{u_4, u_2} D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
h : S.Exact
F : C ⥤ D
inst✝² : F.PreservesZeroMorphisms
inst✝¹ : F.PreservesLeftHomologyOf S
inst✝ : F.PreservesRightHomologyOf S
this : S.HasHomology
⊢ (S.map F).Exact
state_after: no goals
tactic: exact h.map_of_preservesLeftHomologyOf F
Theorem: Polynomial.trailingDegree_neg
File: Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Ring R
p : R[X]
⊢ (-p).trailingDegree = p.trailingDegree
state_after: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Ring R
p : R[X]
⊢ (-p).support.min = p.support.min
tactic: unfold trailingDegree
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Ring R
p : R[X]
⊢ (-p).support.min = p.support.min
state_after: no goals
tactic: rw [support_neg]
Theorem: ProbabilityTheory.Kernel.sum_comm
File: Mathlib/Probability/Kernel/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
inst✝ : Countable ι
κ : ι → ι → Kernel α β
⊢ (Kernel.sum fun n => Kernel.sum (κ n)) = Kernel.sum fun m => Kernel.sum fun n => κ n m
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
inst✝ : Countable ι
κ : ι → ι → Kernel α β
a : α
s : Set β
a✝ : MeasurableSet s
⊢ ((Kernel.sum fun n => Kernel.sum (κ n)) a) s = ((Kernel.sum fun m => Kernel.sum fun n => κ n m) a) s
tactic: ext a s
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
inst✝ : Countable ι
κ : ι → ι → Kernel α β
a : α
s : Set β
a✝ : MeasurableSet s
⊢ ((Kernel.sum fun n => Kernel.sum (κ n)) a) s = ((Kernel.sum fun m => Kernel.sum fun n => κ n m) a) s
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
inst✝ : Countable ι
κ : ι → ι → Kernel α β
a : α
s : Set β
a✝ : MeasurableSet s
⊢ (Measure.sum fun n => Measure.sum fun n_1 => (κ n n_1) a) s =
    (Measure.sum fun n => Measure.sum fun n_1 => (κ n_1 n) a) s
tactic: simp_rw [sum_apply]
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
inst✝ : Countable ι
κ : ι → ι → Kernel α β
a : α
s : Set β
a✝ : MeasurableSet s
⊢ (Measure.sum fun n => Measure.sum fun n_1 => (κ n n_1) a) s =
    (Measure.sum fun n => Measure.sum fun n_1 => (κ n_1 n) a) s
state_after: no goals
tactic: rw [Measure.sum_comm]
Theorem: Finset.SupIndep.biUnion
File: Mathlib/Order/SupIndep.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝² : DistribLattice α
inst✝¹ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
inst✝ : DecidableEq ι
s : Finset ι'
g : ι' → Finset ι
f : ι → α
hs : s.SupIndep fun i => (g i).sup f
hg : ∀ i' ∈ s, (g i').SupIndep f
⊢ (s.biUnion g).SupIndep f
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝² : DistribLattice α
inst✝¹ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
inst✝ : DecidableEq ι
s : Finset ι'
g : ι' → Finset ι
f : ι → α
hs : s.SupIndep fun i => (g i).sup f
hg : ∀ i' ∈ s, (g i').SupIndep f
⊢ (s.sup g).SupIndep f
tactic: rw [← sup_eq_biUnion]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝² : DistribLattice α
inst✝¹ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
inst✝ : DecidableEq ι
s : Finset ι'
g : ι' → Finset ι
f : ι → α
hs : s.SupIndep fun i => (g i).sup f
hg : ∀ i' ∈ s, (g i').SupIndep f
⊢ (s.sup g).SupIndep f
state_after: no goals
tactic: exact hs.sup hg
Theorem: PolyEquivTensor.toFunLinear_mul_tmul_mul_aux_2
File: Mathlib/RingTheory/PolynomialAlgebra.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
k : ℕ
a₁ a₂ : A
p₁ p₂ : R[X]
⊢ a₁ * a₂ * (algebraMap R A) ((p₁ * p₂).coeff k) =
    ∑ x ∈ Finset.antidiagonal k, a₁ * (algebraMap R A) (p₁.coeff x.1) * (a₂ * (algebraMap R A) (p₂.coeff x.2))
state_after: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
k : ℕ
a₁ a₂ : A
p₁ p₂ : R[X]
⊢ a₁ * (a₂ * (algebraMap R A) ((p₁ * p₂).coeff k)) =
    a₁ * (a₂ * ∑ i ∈ Finset.antidiagonal k, (algebraMap R A) (p₂.coeff i.2) * (algebraMap R A) (p₁.coeff i.1))
tactic: simp_rw [mul_assoc, Algebra.commutes, ← Finset.mul_sum, mul_assoc, ← Finset.mul_sum]
state_before: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
k : ℕ
a₁ a₂ : A
p₁ p₂ : R[X]
⊢ a₁ * (a₂ * (algebraMap R A) ((p₁ * p₂).coeff k)) =
    a₁ * (a₂ * ∑ i ∈ Finset.antidiagonal k, (algebraMap R A) (p₂.coeff i.2) * (algebraMap R A) (p₁.coeff i.1))
state_after: case e_a.e_a
R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
k : ℕ
a₁ a₂ : A
p₁ p₂ : R[X]
⊢ (algebraMap R A) ((p₁ * p₂).coeff k) =
    ∑ i ∈ Finset.antidiagonal k, (algebraMap R A) (p₂.coeff i.2) * (algebraMap R A) (p₁.coeff i.1)
tactic: congr
state_before: case e_a.e_a
R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
k : ℕ
a₁ a₂ : A
p₁ p₂ : R[X]
⊢ (algebraMap R A) ((p₁ * p₂).coeff k) =
    ∑ i ∈ Finset.antidiagonal k, (algebraMap R A) (p₂.coeff i.2) * (algebraMap R A) (p₁.coeff i.1)
state_after: no goals
tactic: simp_rw [Algebra.commutes (coeff p₂ _), coeff_mul, map_sum, RingHom.map_mul]