ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: indicator_biUnion_finset_eventuallyEq
File: Mathlib/Order/Filter/IndicatorFunction.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
M : Type u_3
E : Type u_4
ι : Type u_5
inst✝ : One β
s : ι → Set α
f : α → β
a : α
⊢ (fun n => (⋃ i ∈ n, s i).mulIndicator f a) =ᶠ[atTop] fun x => (iUnion s).mulIndicator f a
state_after: α : Type u_1
β : Type u_2
M : Type u_3
E : Type u_4
ι : Type u_5
inst✝ : One β
s : ι → Set α
f : α → β
a : α
⊢ (fun n => (⋃ i ∈ n, s i).mulIndicator f a) =ᶠ[atTop] fun x => (⋃ t, ⋃ i ∈ t, s i).mulIndicator f a
tactic: rw [iUnion_eq_iUnion_finset s]
state_before: α : Type u_1
β : Type u_2
M : Type u_3
E : Type u_4
ι : Type u_5
inst✝ : One β
s : ι → Set α
f : α → β
a : α
⊢ (fun n => (⋃ i ∈ n, s i).mulIndicator f a) =ᶠ[atTop] fun x => (⋃ t, ⋃ i ∈ t, s i).mulIndicator f a
state_after: case hs
α : Type u_1
β : Type u_2
M : Type u_3
E : Type u_4
ι : Type u_5
inst✝ : One β
s : ι → Set α
f : α → β
a : α
⊢ Monotone fun i => ⋃ i_1 ∈ i, s i_1
tactic: apply Monotone.mulIndicator_eventuallyEq_iUnion
state_before: case hs
α : Type u_1
β : Type u_2
M : Type u_3
E : Type u_4
ι : Type u_5
inst✝ : One β
s : ι → Set α
f : α → β
a : α
⊢ Monotone fun i => ⋃ i_1 ∈ i, s i_1
state_after: no goals
tactic: exact fun _ _ ↦ biUnion_subset_biUnion_left
Theorem: AddAction.fixedBy_neg
File: Mathlib/GroupTheory/GroupAction/FixedPoints.lean

Proof steps:
state_before: α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
g : G
⊢ fixedBy α g⁻¹ = fixedBy α g
state_after: case h
α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
g : G
x✝ : α
⊢ x✝ ∈ fixedBy α g⁻¹ ↔ x✝ ∈ fixedBy α g
tactic: ext
state_before: case h
α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
g : G
x✝ : α
⊢ x✝ ∈ fixedBy α g⁻¹ ↔ x✝ ∈ fixedBy α g
state_after: no goals
tactic: rw [mem_fixedBy, mem_fixedBy, inv_smul_eq_iff, eq_comm]
Theorem: Real.one_le_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x✝ y z✝ : ℝ
n : ℕ
x z : ℝ
hx : 1 ≤ x
hz : 0 ≤ z
⊢ 1 ≤ x ^ z
state_after: x✝ y z✝ : ℝ
n : ℕ
x z : ℝ
hx : 1 ≤ x
hz : 0 ≤ z
⊢ 1 ^ z ≤ x ^ z
tactic: rw [← one_rpow z]
state_before: x✝ y z✝ : ℝ
n : ℕ
x z : ℝ
hx : 1 ≤ x
hz : 0 ≤ z
⊢ 1 ^ z ≤ x ^ z
state_after: no goals
tactic: exact rpow_le_rpow zero_le_one hx hz
Theorem: FirstOrder.Language.BoundedFormula.realize_ex
File: Mathlib/ModelTheory/Semantics.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
⊢ (∃'θ).Realize v xs ↔ ∃ a, θ.Realize v (snoc xs a)
state_after: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
⊢ (∃ x, ¬(∼θ).Realize v (snoc xs x)) ↔ ∃ a, θ.Realize v (snoc xs a)
tactic: rw [BoundedFormula.ex, realize_not, realize_all, not_forall]
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n l : ℕ
φ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v : α → M
xs : Fin l → M
⊢ (∃ x, ¬(∼θ).Realize v (snoc xs x)) ↔ ∃ a, θ.Realize v (snoc xs a)
state_after: no goals
tactic: simp_rw [realize_not, Classical.not_not]
Theorem: CategoryTheory.bifunctorComp₂₃Obj_map_app
File: Mathlib/CategoryTheory/Functor/Trifunctor.lean

Proof steps:
state_before: C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
C₁₂ : Type u_5
C₂₃ : Type u_6
inst✝⁵ : Category.{?u.16016, u_1} C₁
inst✝⁴ : Category.{?u.16020, u_2} C₂
inst✝³ : Category.{?u.16024, u_3} C₃
inst✝² : Category.{?u.16028, u_4} C₄
inst✝¹ : Category.{?u.16032, u_5} C₁₂
inst✝ : Category.{?u.16036, u_6} C₂₃
F : C₁ ⥤ C₂₃ ⥤ C₄
G₂₃ : C₂ ⥤ C₃ ⥤ C₂₃
X₁ : C₁
X₂ Y₂ : C₂
φ✝ : X₂ ⟶ Y₂
X₃ Y₃ : C₃
φ : X₃ ⟶ Y₃
⊢ ((fun X₂ =>
              { obj := fun X₃ => (F.obj X₁).obj ((G₂₃.obj X₂).obj X₃),
                map := fun {X₃ Y₃} φ => (F.obj X₁).map ((G₂₃.obj X₂).map φ), map_id := ⋯, map_comp := ⋯ })
            X₂).map
        φ ≫
      (fun X₃ => (F.obj X₁).map ((G₂₃.map φ✝).app X₃)) Y₃ =
    (fun X₃ => (F.obj X₁).map ((G₂₃.map φ✝).app X₃)) X₃ ≫
      ((fun X₂ =>
              { obj := fun X₃ => (F.obj X₁).obj ((G₂₃.obj X₂).obj X₃),
                map := fun {X₃ Y₃} φ => (F.obj X₁).map ((G₂₃.obj X₂).map φ), map_id := ⋯, map_comp := ⋯ })
            Y₂).map
        φ
state_after: C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
C₁₂ : Type u_5
C₂₃ : Type u_6
inst✝⁵ : Category.{?u.16016, u_1} C₁
inst✝⁴ : Category.{?u.16020, u_2} C₂
inst✝³ : Category.{?u.16024, u_3} C₃
inst✝² : Category.{?u.16028, u_4} C₄
inst✝¹ : Category.{?u.16032, u_5} C₁₂
inst✝ : Category.{?u.16036, u_6} C₂₃
F : C₁ ⥤ C₂₃ ⥤ C₄
G₂₃ : C₂ ⥤ C₃ ⥤ C₂₃
X₁ : C₁
X₂ Y₂ : C₂
φ✝ : X₂ ⟶ Y₂
X₃ Y₃ : C₃
φ : X₃ ⟶ Y₃
⊢ (F.obj X₁).map ((G₂₃.obj X₂).map φ) ≫ (F.obj X₁).map ((G₂₃.map φ✝).app Y₃) =
    (F.obj X₁).map ((G₂₃.map φ✝).app X₃) ≫ (F.obj X₁).map ((G₂₃.obj Y₂).map φ)
tactic: dsimp
state_before: C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
C₁₂ : Type u_5
C₂₃ : Type u_6
inst✝⁵ : Category.{?u.16016, u_1} C₁
inst✝⁴ : Category.{?u.16020, u_2} C₂
inst✝³ : Category.{?u.16024, u_3} C₃
inst✝² : Category.{?u.16028, u_4} C₄
inst✝¹ : Category.{?u.16032, u_5} C₁₂
inst✝ : Category.{?u.16036, u_6} C₂₃
F : C₁ ⥤ C₂₃ ⥤ C₄
G₂₃ : C₂ ⥤ C₃ ⥤ C₂₃
X₁ : C₁
X₂ Y₂ : C₂
φ✝ : X₂ ⟶ Y₂
X₃ Y₃ : C₃
φ : X₃ ⟶ Y₃
⊢ (F.obj X₁).map ((G₂₃.obj X₂).map φ) ≫ (F.obj X₁).map ((G₂₃.map φ✝).app Y₃) =
    (F.obj X₁).map ((G₂₃.map φ✝).app X₃) ≫ (F.obj X₁).map ((G₂₃.obj Y₂).map φ)
state_after: no goals
tactic: simp only [← Functor.map_comp, NatTrans.naturality]
Theorem: CategoryTheory.Limits.CokernelCofork.mapIsoOfIsColimit_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
X' Y' : C
f' : X' ⟶ Y'
cc : CokernelCofork f
cc' : CokernelCofork f'
hf : IsColimit cc
hf' : IsColimit cc'
φ : Arrow.mk f ≅ Arrow.mk f'
⊢ Cofork.π cc ≫ mapOfIsColimit hf cc' φ.hom ≫ mapOfIsColimit hf' cc φ.inv = Cofork.π cc ≫ 𝟙 cc.pt
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
X' Y' : C
f' : X' ⟶ Y'
cc : CokernelCofork f
cc' : CokernelCofork f'
hf : IsColimit cc
hf' : IsColimit cc'
φ : Arrow.mk f ≅ Arrow.mk f'
⊢ Cofork.π cc' ≫ mapOfIsColimit hf' cc φ.inv ≫ mapOfIsColimit hf cc' φ.hom = Cofork.π cc' ≫ 𝟙 cc'.pt
state_after: no goals
tactic: simp
Theorem: Sum.isPreconnected_iff
File: Mathlib/Topology/Connected/Clopen.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : TopologicalSpace β
s : Set (α ⊕ β)
⊢ IsPreconnected s ↔ (∃ t, IsPreconnected t ∧ s = inl '' t) ∨ ∃ t, IsPreconnected t ∧ s = inr '' t
state_after: case refine_1
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : TopologicalSpace β
s : Set (α ⊕ β)
hs : IsPreconnected s
⊢ (∃ t, IsPreconnected t ∧ s = inl '' t) ∨ ∃ t, IsPreconnected t ∧ s = inr '' t

case refine_2
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : TopologicalSpace β
s : Set (α ⊕ β)
⊢ ((∃ t, IsPreconnected t ∧ s = inl '' t) ∨ ∃ t, IsPreconnected t ∧ s = inr '' t) → IsPreconnected s
tactic: refine ⟨fun hs => ?_, ?_⟩
Theorem: variationOnFromTo.eq_neg_swap
File: Mathlib/Analysis/BoundedVariation.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
a b : α
⊢ variationOnFromTo f s a b = -variationOnFromTo f s b a
state_after: case inl
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
a b : α
ab : a < b
⊢ variationOnFromTo f s a b = -variationOnFromTo f s b a

case inr.inl
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
a : α
⊢ variationOnFromTo f s a a = -variationOnFromTo f s a a

case inr.inr
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
a b : α
ba : b < a
⊢ variationOnFromTo f s a b = -variationOnFromTo f s b a
tactic: rcases lt_trichotomy a b with (ab | rfl | ba)
Theorem: Finset.prod_add_prod_eq
File: Mathlib/Algebra/BigOperators/Ring.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
s✝ s₁ s₂ : Finset ι
i✝ : ι
a : α
f✝ g✝ : ι → α
inst✝ : CommSemiring α
s : Finset ι
i : ι
f g h : ι → α
hi : i ∈ s
h1 : g i + h i = f i
h2 : ∀ j ∈ s, j ≠ i → g j = f j
h3 : ∀ j ∈ s, j ≠ i → h j = f j
⊢ ∏ i ∈ s, g i + ∏ i ∈ s, h i = ∏ i ∈ s, f i
state_after: no goals
tactic: classical
    simp_rw [prod_eq_mul_prod_diff_singleton hi, ← h1, right_distrib]
    congr 2 <;> apply prod_congr rfl <;> simpa
Theorem: Mathlib.Tactic.Ring.add_pf_zero_add
File: Mathlib/Tactic/Ring/Basic.lean

Proof steps:
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R : Type u_1
inst✝ : CommSemiring R
a a' a₁ a₂ a₃ b✝ b' b₁ b₂ b₃ c c₁ c₂ b : R
⊢ 0 + b = b
state_after: no goals
tactic: simp
Theorem: Filter.EventuallyEq.iteratedFDerivWithin'
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : f₁ =ᶠ[𝓝[s] x] f
ht : t ⊆ s
n : ℕ
⊢ iteratedFDerivWithin 𝕜 n f₁ t =ᶠ[𝓝[s] x] iteratedFDerivWithin 𝕜 n f t
state_after: case zero
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : f₁ =ᶠ[𝓝[s] x] f
ht : t ⊆ s
⊢ iteratedFDerivWithin 𝕜 0 f₁ t =ᶠ[𝓝[s] x] iteratedFDerivWithin 𝕜 0 f t

case succ
𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : f₁ =ᶠ[𝓝[s] x] f
ht : t ⊆ s
n : ℕ
ihn : iteratedFDerivWithin 𝕜 n f₁ t =ᶠ[𝓝[s] x] iteratedFDerivWithin 𝕜 n f t
⊢ iteratedFDerivWithin 𝕜 (n + 1) f₁ t =ᶠ[𝓝[s] x] iteratedFDerivWithin 𝕜 (n + 1) f t
tactic: induction' n with n ihn
Theorem: groupCohomology.oneCoboundaries_eq_bot_of_isTrivial
File: Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean

Proof steps:
state_before: k G : Type u
inst✝² : CommRing k
inst✝¹ : Group G
A✝ A : Rep k G
inst✝ : A.IsTrivial
⊢ oneCoboundaries A = ⊥
state_after: k G : Type u
inst✝² : CommRing k
inst✝¹ : Group G
A✝ A : Rep k G
inst✝ : A.IsTrivial
⊢ LinearMap.range (LinearMap.codRestrict (oneCocycles A) 0 ⋯) = ⊥
tactic: simp_rw [oneCoboundaries, dZero_eq_zero]
state_before: k G : Type u
inst✝² : CommRing k
inst✝¹ : Group G
A✝ A : Rep k G
inst✝ : A.IsTrivial
⊢ LinearMap.range (LinearMap.codRestrict (oneCocycles A) 0 ⋯) = ⊥
state_after: no goals
tactic: exact LinearMap.range_eq_bot.2 rfl
Theorem: ZMod.χ₄_int_mod_four
File: Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean

Proof steps:
state_before: n : ℤ
⊢ χ₄ ↑n = χ₄ ↑(n % 4)
state_after: no goals
tactic: rw [← ZMod.intCast_mod n 4, Nat.cast_ofNat]
Theorem: mul_inv
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✝ : DivisionCommMonoid α
a b c d : α
⊢ (a * b)⁻¹ = a⁻¹ * b⁻¹
state_after: no goals
tactic: simp
Theorem: EReal.log_exp
File: Mathlib/Analysis/SpecialFunctions/Log/ENNRealLogExp.lean

Proof steps:
state_before: x : EReal
⊢ x.exp.log = x
state_after: case h_bot

⊢ ⊥.exp.log = ⊥

case h_real
a✝ : ℝ
⊢ (↑a✝).exp.log = ↑a✝

case h_top

⊢ ⊤.exp.log = ⊤
tactic: induction x
Theorem: ZNum.cast_le
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
m n : ZNum
⊢ ↑m ≤ ↑n ↔ m ≤ n
state_after: α : Type u_1
inst✝ : LinearOrderedRing α
m n : ZNum
⊢ ¬↑n < ↑m ↔ m ≤ n
tactic: rw [← not_lt]
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
m n : ZNum
⊢ ¬↑n < ↑m ↔ m ≤ n
state_after: no goals
tactic: exact not_congr cast_lt
Theorem: IsSelfAdjoint.adjoint_conj
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁸ : RCLike 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : InnerProductSpace 𝕜 F
inst✝² : InnerProductSpace 𝕜 G
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
T : E →L[𝕜] E
hT : IsSelfAdjoint T
S : F →L[𝕜] E
⊢ IsSelfAdjoint ((adjoint S).comp (T.comp S))
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁸ : RCLike 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : InnerProductSpace 𝕜 F
inst✝² : InnerProductSpace 𝕜 G
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
T : E →L[𝕜] E
hT : adjoint T = T
S : F →L[𝕜] E
⊢ adjoint ((adjoint S).comp (T.comp S)) = (adjoint S).comp (T.comp S)
tactic: rw [isSelfAdjoint_iff'] at hT ⊢
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁸ : RCLike 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : InnerProductSpace 𝕜 F
inst✝² : InnerProductSpace 𝕜 G
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
T : E →L[𝕜] E
hT : adjoint T = T
S : F →L[𝕜] E
⊢ adjoint ((adjoint S).comp (T.comp S)) = (adjoint S).comp (T.comp S)
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁸ : RCLike 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : InnerProductSpace 𝕜 F
inst✝² : InnerProductSpace 𝕜 G
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
T : E →L[𝕜] E
hT : adjoint T = T
S : F →L[𝕜] E
⊢ ((adjoint S).comp T).comp S = (adjoint S).comp (T.comp S)
tactic: simp only [hT, adjoint_comp, adjoint_adjoint]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁸ : RCLike 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : InnerProductSpace 𝕜 F
inst✝² : InnerProductSpace 𝕜 G
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
T : E →L[𝕜] E
hT : adjoint T = T
S : F →L[𝕜] E
⊢ ((adjoint S).comp T).comp S = (adjoint S).comp (T.comp S)
state_after: no goals
tactic: exact ContinuousLinearMap.comp_assoc _ _ _
Theorem: CategoryTheory.ShortComplex.moduleCat_exact_iff_range_eq_ker
File: Mathlib/Algebra/Homology/ShortComplex/ModuleCat.lean

Proof steps:
state_before: R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
⊢ S.Exact ↔ LinearMap.range S.f = LinearMap.ker S.g
state_after: R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
⊢ LinearMap.ker S.g ≤ LinearMap.range S.f ↔ LinearMap.range S.f = LinearMap.ker S.g
tactic: rw [moduleCat_exact_iff_ker_sub_range]
state_before: R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
⊢ LinearMap.ker S.g ≤ LinearMap.range S.f ↔ LinearMap.range S.f = LinearMap.ker S.g
state_after: case mp
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
⊢ LinearMap.ker S.g ≤ LinearMap.range S.f → LinearMap.range S.f = LinearMap.ker S.g

case mpr
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
⊢ LinearMap.range S.f = LinearMap.ker S.g → LinearMap.ker S.g ≤ LinearMap.range S.f
tactic: constructor
Theorem: EisensteinSeries.div_linear_zpow_differentiableOn
File: Mathlib/NumberTheory/ModularForms/EisensteinSeries/MDifferentiable.lean

Proof steps:
state_before: k : ℤ
a : Fin 2 → ℤ
⊢ DifferentiableOn ℂ (fun z => (↑(a 0) * z + ↑(a 1)) ^ (-k)) {z | 0 < z.im}
state_after: case inl
k : ℤ
a : Fin 2 → ℤ
ha : a ≠ 0
⊢ DifferentiableOn ℂ (fun z => (↑(a 0) * z + ↑(a 1)) ^ (-k)) {z | 0 < z.im}

case inr
k : ℤ
⊢ DifferentiableOn ℂ (fun z => (↑(0 0) * z + ↑(0 1)) ^ (-k)) {z | 0 < z.im}
tactic: rcases ne_or_eq a 0 with ha | rfl
Theorem: CompactSpace.uniformEquicontinuous_of_equicontinuous
File: Mathlib/Topology/UniformSpace/Compact.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
ι : Type u_4
F : ι → β → α
inst✝ : CompactSpace β
h : Equicontinuous F
⊢ UniformEquicontinuous F
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
ι : Type u_4
F : ι → β → α
inst✝ : CompactSpace β
h : Continuous (⇑UniformFun.ofFun ∘ Function.swap F)
⊢ UniformEquicontinuous F
tactic: rw [equicontinuous_iff_continuous] at h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
ι : Type u_4
F : ι → β → α
inst✝ : CompactSpace β
h : Continuous (⇑UniformFun.ofFun ∘ Function.swap F)
⊢ UniformEquicontinuous F
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
ι : Type u_4
F : ι → β → α
inst✝ : CompactSpace β
h : Continuous (⇑UniformFun.ofFun ∘ Function.swap F)
⊢ UniformContinuous (⇑UniformFun.ofFun ∘ Function.swap F)
tactic: rw [uniformEquicontinuous_iff_uniformContinuous]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
ι : Type u_4
F : ι → β → α
inst✝ : CompactSpace β
h : Continuous (⇑UniformFun.ofFun ∘ Function.swap F)
⊢ UniformContinuous (⇑UniformFun.ofFun ∘ Function.swap F)
state_after: no goals
tactic: exact CompactSpace.uniformContinuous_of_continuous h
Theorem: PowerSeries.trunc_zero
File: Mathlib/RingTheory/PowerSeries/Trunc.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
n m : ℕ
⊢ (trunc n 0).coeff m = Polynomial.coeff 0 m
state_after: R : Type u_1
inst✝ : Semiring R
n m : ℕ
⊢ (if m < n then 0 else 0) = 0
tactic: rw [coeff_trunc, LinearMap.map_zero, Polynomial.coeff_zero]
state_before: R : Type u_1
inst✝ : Semiring R
n m : ℕ
⊢ (if m < n then 0 else 0) = 0
state_after: no goals
tactic: split_ifs <;> rfl
Theorem: MeasureTheory.SimpleFunc.restrict_mono
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : MeasurableSpace α
K : Type u_5
inst✝¹ : Zero β
inst✝ : Preorder β
s : Set α
f g : α →ₛ β
H : f ≤ g
hs : MeasurableSet s
x : α
⊢ ↑(f.restrict s) x ≤ ↑(g.restrict s) x
state_after: no goals
tactic: simp only [coe_restrict _ hs, indicator_le_indicator (H x)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : MeasurableSpace α
K : Type u_5
inst✝¹ : Zero β
inst✝ : Preorder β
s : Set α
f g : α →ₛ β
H : f ≤ g
hs : ¬MeasurableSet s
⊢ f.restrict s ≤ g.restrict s
state_after: no goals
tactic: simp only [restrict_of_not_measurable hs, le_refl]
Theorem: Cardinal.mk_equiv_eq_arrow_of_lift_eq
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
⊢ #(α ≃ β') = #(α → β')
state_after: case intro
α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
e : α ≃ β'
⊢ #(α ≃ β') = #(α → β')
tactic: obtain ⟨e⟩ := lift_mk_eq'.mp leq
state_before: case intro
α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
e : α ≃ β'
⊢ #(α ≃ β') = #(α → β')
state_after: case intro
α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
e : α ≃ β'
e₁ : lift.{max u v, u} #(α ≃ α) = lift.{u, max u v} #(α ≃ β')
⊢ #(α ≃ β') = #(α → β')
tactic: have e₁ := lift_mk_eq'.mpr ⟨.equivCongr (.refl α) e⟩
state_before: case intro
α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
e : α ≃ β'
e₁ : lift.{max u v, u} #(α ≃ α) = lift.{u, max u v} #(α ≃ β')
⊢ #(α ≃ β') = #(α → β')
state_after: case intro
α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
e : α ≃ β'
e₁ : lift.{max u v, u} #(α ≃ α) = lift.{u, max u v} #(α ≃ β')
e₂ : lift.{max u v, u} #(α → α) = lift.{u, max u v} #(α → β')
⊢ #(α ≃ β') = #(α → β')
tactic: have e₂ := lift_mk_eq'.mpr ⟨.arrowCongr (.refl α) e⟩
state_before: case intro
α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
e : α ≃ β'
e₁ : lift.{max u v, u} #(α ≃ α) = lift.{u, max u v} #(α ≃ β')
e₂ : lift.{max u v, u} #(α → α) = lift.{u, max u v} #(α → β')
⊢ #(α ≃ β') = #(α → β')
state_after: case intro
α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
e : α ≃ β'
e₁ : lift.{max u v, u} #(α ≃ α) = #(α ≃ β')
e₂ : lift.{max u v, u} #(α → α) = #(α → β')
⊢ #(α ≃ β') = #(α → β')
tactic: rw [lift_id'.{u,v}] at e₁ e₂
state_before: case intro
α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
e : α ≃ β'
e₁ : lift.{max u v, u} #(α ≃ α) = #(α ≃ β')
e₂ : lift.{max u v, u} #(α → α) = #(α → β')
⊢ #(α ≃ β') = #(α → β')
state_after: no goals
tactic: rw [← e₁, ← e₂, lift_inj, mk_perm_eq_self_power, power_def]
Theorem: Matroid.comapOn_base_iff_of_surjOn
File: Mathlib/Data/Matroid/Map.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f : α → β
E✝ I✝ s : Set α
M : Matroid α
N : Matroid β
E B I : Set α
h : SurjOn f E N.E
⊢ (N.comapOn E f).Base B ↔ N.Base (f '' B) ∧ InjOn f B ∧ B ⊆ E
state_after: no goals
tactic: simp_rw [comapOn_base_iff, and_congr_left_iff, and_imp,
    basis'_iff_basis_inter_ground, inter_eq_self_of_subset_right h, basis_ground_iff, implies_true]
Theorem: Multiset.map_congr
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
f g : α → β
s t : Multiset α
⊢ s = t → (∀ x ∈ t, f x = g x) → map f s = map g t
state_after: α : Type u_1
β : Type v
γ : Type u_2
f g : α → β
s : Multiset α
h : ∀ x ∈ s, f x = g x
⊢ map f s = map g s
tactic: rintro rfl h
state_before: α : Type u_1
β : Type v
γ : Type u_2
f g : α → β
s : Multiset α
h : ∀ x ∈ s, f x = g x
⊢ map f s = map g s
state_after: case h
α : Type u_1
β : Type v
γ : Type u_2
f g : α → β
a✝ : List α
h : ∀ x ∈ Quot.mk Setoid.r a✝, f x = g x
⊢ map f (Quot.mk Setoid.r a✝) = map g (Quot.mk Setoid.r a✝)
tactic: induction s using Quot.inductionOn
state_before: case h
α : Type u_1
β : Type v
γ : Type u_2
f g : α → β
a✝ : List α
h : ∀ x ∈ Quot.mk Setoid.r a✝, f x = g x
⊢ map f (Quot.mk Setoid.r a✝) = map g (Quot.mk Setoid.r a✝)
state_after: no goals
tactic: exact congr_arg _ (List.map_congr_left h)