ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AdjoinRoot.quotEquivQuotMap_symm_apply_mk
File: Mathlib/RingTheory/AdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
I✝ : Ideal R
f✝ f g : R[X]
I : Ideal R
⊢ (quotEquivQuotMap f I).symm
      ((Ideal.Quotient.mk (span {Polynomial.map (Ideal.Quotient.mk I) f})) (Polynomial.map (Ideal.Quotient.mk I) g)) =
    (Ideal.Quotient.mk (Ideal.map (of f) I)) ((mk f) g)
state_after: no goals
tactic: rw [AdjoinRoot.quotEquivQuotMap_symm_apply,
    AdjoinRoot.quotAdjoinRootEquivQuotPolynomialQuot_symm_mk_mk]
Theorem: Finset.Colex.toColex_le_singleton
File: Mathlib/Combinatorics/Colex.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b : α
⊢ { ofColex := s } ≤ { ofColex := {a} } ↔ ∀ b ∈ s, b ≤ a ∧ (a ∈ s → b = a)
state_after: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b : α
⊢ (∀ ⦃a_1 : α⦄, a_1 ∈ s → ¬a_1 = a → a ∉ s ∧ a_1 ≤ a) ↔ ∀ b ∈ s, b ≤ a ∧ (a ∈ s → b = a)
tactic: simp only [toColex_le_toColex, mem_singleton, and_assoc, exists_eq_left]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b : α
⊢ (∀ ⦃a_1 : α⦄, a_1 ∈ s → ¬a_1 = a → a ∉ s ∧ a_1 ≤ a) ↔ ∀ b ∈ s, b ≤ a ∧ (a ∈ s → b = a)
state_after: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b✝ b : α
x✝ : b ∈ s
⊢ ¬b = a → a ∉ s ∧ b ≤ a ↔ b ≤ a ∧ (a ∈ s → b = a)
tactic: refine forall₂_congr fun b _ ↦ ?_
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b✝ b : α
x✝ : b ∈ s
⊢ ¬b = a → a ∉ s ∧ b ≤ a ↔ b ≤ a ∧ (a ∈ s → b = a)
state_after: no goals
tactic: obtain rfl | hba := eq_or_ne b a <;> aesop
Theorem: Fin.one_succAbove_succ
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n✝ m : ℕ
p : Fin (n✝ + 1)
i j✝ : Fin n✝
n : ℕ
j : Fin n
⊢ succAbove 1 j.succ = j.succ.succ
state_after: n✝ m : ℕ
p : Fin (n✝ + 1)
i j✝ : Fin n✝
n : ℕ
j : Fin n
this : (succ 0).succAbove j.succ = (succAbove 0 j).succ
⊢ succAbove 1 j.succ = j.succ.succ
tactic: have := succ_succAbove_succ 0 j
state_before: n✝ m : ℕ
p : Fin (n✝ + 1)
i j✝ : Fin n✝
n : ℕ
j : Fin n
this : (succ 0).succAbove j.succ = (succAbove 0 j).succ
⊢ succAbove 1 j.succ = j.succ.succ
state_after: no goals
tactic: rwa [succ_zero_eq_one, zero_succAbove] at this
Theorem: TypeVec.repeatEq_iff_eq
File: Mathlib/Data/TypeVec.lean

Proof steps:
state_before: n : ℕ
α : TypeVec.{u_1} n
i : Fin2 n
x y : α i
⊢ ofRepeat (α.repeatEq i (prod.mk i x y)) ↔ x = y
state_after: case fz
n n✝ : ℕ
α : TypeVec.{u_1} (n✝ + 1)
x y : α Fin2.fz
⊢ ofRepeat (α.repeatEq Fin2.fz (prod.mk Fin2.fz x y)) ↔ x = y

case fs
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α : TypeVec.{u_1} n✝} {x y : α a✝}, ofRepeat (α.repeatEq a✝ (prod.mk a✝ x y)) ↔ x = y
α : TypeVec.{u_1} (n✝ + 1)
x y : α a✝.fs
⊢ ofRepeat (α.repeatEq a✝.fs (prod.mk a✝.fs x y)) ↔ x = y
tactic: induction' i with _ _ _ i_ih
state_before: case fs
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α : TypeVec.{u_1} n✝} {x y : α a✝}, ofRepeat (α.repeatEq a✝ (prod.mk a✝ x y)) ↔ x = y
α : TypeVec.{u_1} (n✝ + 1)
x y : α a✝.fs
⊢ ofRepeat (α.repeatEq a✝.fs (prod.mk a✝.fs x y)) ↔ x = y
state_after: no goals
tactic: erw [repeatEq, i_ih]
Theorem: CategoryTheory.Comma.coconeOfPreserves_ι_app_right
File: Mathlib/CategoryTheory/Limits/Comma.lean

Proof steps:
state_before: J : Type w
inst✝⁴ : Category.{w', w} J
A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
T : Type u₃
inst✝¹ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
F : J ⥤ Comma L R
inst✝ : PreservesColimit (F ⋙ fst L R) L
c₁ : Cocone (F ⋙ fst L R)
t₁ : IsColimit c₁
c₂ : Cocone (F ⋙ snd L R)
j₁ j₂ : J
t : j₁ ⟶ j₂
⊢ F.map t ≫ (fun j => { left := c₁.ι.app j, right := c₂.ι.app j, w := ⋯ }) j₂ =
    (fun j => { left := c₁.ι.app j, right := c₂.ι.app j, w := ⋯ }) j₁ ≫
      ((Functor.const J).obj
            { left := c₁.pt, right := c₂.pt,
              hom := (isColimitOfPreserves L t₁).desc (colimitAuxiliaryCocone F c₂) }).map
        t
state_after: case h₁
J : Type w
inst✝⁴ : Category.{w', w} J
A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
T : Type u₃
inst✝¹ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
F : J ⥤ Comma L R
inst✝ : PreservesColimit (F ⋙ fst L R) L
c₁ : Cocone (F ⋙ fst L R)
t₁ : IsColimit c₁
c₂ : Cocone (F ⋙ snd L R)
j₁ j₂ : J
t : j₁ ⟶ j₂
⊢ (F.map t ≫ (fun j => { left := c₁.ι.app j, right := c₂.ι.app j, w := ⋯ }) j₂).left =
    ((fun j => { left := c₁.ι.app j, right := c₂.ι.app j, w := ⋯ }) j₁ ≫
        ((Functor.const J).obj
              { left := c₁.pt, right := c₂.pt,
                hom := (isColimitOfPreserves L t₁).desc (colimitAuxiliaryCocone F c₂) }).map
          t).left

case h₂
J : Type w
inst✝⁴ : Category.{w', w} J
A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
T : Type u₃
inst✝¹ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
F : J ⥤ Comma L R
inst✝ : PreservesColimit (F ⋙ fst L R) L
c₁ : Cocone (F ⋙ fst L R)
t₁ : IsColimit c₁
c₂ : Cocone (F ⋙ snd L R)
j₁ j₂ : J
t : j₁ ⟶ j₂
⊢ (F.map t ≫ (fun j => { left := c₁.ι.app j, right := c₂.ι.app j, w := ⋯ }) j₂).right =
    ((fun j => { left := c₁.ι.app j, right := c₂.ι.app j, w := ⋯ }) j₁ ≫
        ((Functor.const J).obj
              { left := c₁.pt, right := c₂.pt,
                hom := (isColimitOfPreserves L t₁).desc (colimitAuxiliaryCocone F c₂) }).map
          t).right
tactic: ext
Theorem: Basis.mem_center_iff
File: Mathlib/LinearAlgebra/Basis.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
A : Type u_10
inst✝⁵ : Semiring R
inst✝⁴ : NonUnitalNonAssocSemiring A
inst✝³ : Module R A
inst✝² : SMulCommClass R A A
inst✝¹ : SMulCommClass R R A
inst✝ : IsScalarTower R A A
b : Basis ι R A
z : A
⊢ z ∈ center A ↔
    (∀ (i : ι), Commute (b i) z) ∧
      ∀ (i j : ι), z * (b i * b j) = z * b i * b j ∧ b i * z * b j = b i * (z * b j) ∧ b i * b j * z = b i * (b j * z)
state_after: case mp
ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
A : Type u_10
inst✝⁵ : Semiring R
inst✝⁴ : NonUnitalNonAssocSemiring A
inst✝³ : Module R A
inst✝² : SMulCommClass R A A
inst✝¹ : SMulCommClass R R A
inst✝ : IsScalarTower R A A
b : Basis ι R A
z : A
⊢ z ∈ center A →
    (∀ (i : ι), Commute (b i) z) ∧
      ∀ (i j : ι), z * (b i * b j) = z * b i * b j ∧ b i * z * b j = b i * (z * b j) ∧ b i * b j * z = b i * (b j * z)

case mpr
ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
A : Type u_10
inst✝⁵ : Semiring R
inst✝⁴ : NonUnitalNonAssocSemiring A
inst✝³ : Module R A
inst✝² : SMulCommClass R A A
inst✝¹ : SMulCommClass R R A
inst✝ : IsScalarTower R A A
b : Basis ι R A
z : A
⊢ ((∀ (i : ι), Commute (b i) z) ∧
      ∀ (i j : ι),
        z * (b i * b j) = z * b i * b j ∧ b i * z * b j = b i * (z * b j) ∧ b i * b j * z = b i * (b j * z)) →
    z ∈ center A
tactic: constructor
Theorem: SetTheory.PGame.le_zero_lf
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x : PGame
⊢ x ≤ 0 ↔ ∀ (i : x.LeftMoves), x.moveLeft i ⧏ 0
state_after: xl xr : Type u
x : PGame
⊢ ((∀ (i : x.LeftMoves), x.moveLeft i ⧏ 0) ∧ ∀ (j : RightMoves 0), x ⧏ moveRight 0 j) ↔
    ∀ (i : x.LeftMoves), x.moveLeft i ⧏ 0
tactic: rw [le_iff_forall_lf]
state_before: xl xr : Type u
x : PGame
⊢ ((∀ (i : x.LeftMoves), x.moveLeft i ⧏ 0) ∧ ∀ (j : RightMoves 0), x ⧏ moveRight 0 j) ↔
    ∀ (i : x.LeftMoves), x.moveLeft i ⧏ 0
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Presheaf.isLocallySurjective_iff_of_fac
File: Mathlib/CategoryTheory/Sites/LocallySurjective.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝² : Category.{v', u'} A
inst✝¹ : ConcreteCategory A
F₁ F₂ F₃ : Cᵒᵖ ⥤ A
f₁ : F₁ ⟶ F₂
f₂ : F₂ ⟶ F₃
f₃ : F₁ ⟶ F₃
fac : f₁ ≫ f₂ = f₃
inst✝ : IsLocallySurjective J f₁
⊢ IsLocallySurjective J f₃ ↔ IsLocallySurjective J f₂
state_after: case mp
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝² : Category.{v', u'} A
inst✝¹ : ConcreteCategory A
F₁ F₂ F₃ : Cᵒᵖ ⥤ A
f₁ : F₁ ⟶ F₂
f₂ : F₂ ⟶ F₃
f₃ : F₁ ⟶ F₃
fac : f₁ ≫ f₂ = f₃
inst✝ : IsLocallySurjective J f₁
⊢ IsLocallySurjective J f₃ → IsLocallySurjective J f₂

case mpr
C : Type u
inst✝³ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝² : Category.{v', u'} A
inst✝¹ : ConcreteCategory A
F₁ F₂ F₃ : Cᵒᵖ ⥤ A
f₁ : F₁ ⟶ F₂
f₂ : F₂ ⟶ F₃
f₃ : F₁ ⟶ F₃
fac : f₁ ≫ f₂ = f₃
inst✝ : IsLocallySurjective J f₁
⊢ IsLocallySurjective J f₂ → IsLocallySurjective J f₃
tactic: constructor
Theorem: sInf_image2_eq_sInf_sInf
File: Mathlib/Order/GaloisConnection.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort u_1
a a₁ a₂ : α
b b₁ b₂ : β
inst✝² : CompleteLattice α
inst✝¹ : CompleteLattice β
inst✝ : CompleteLattice γ
f : α → β → γ
s : Set α
t : Set β
l u : α → β → γ
l₁ u₁ : β → γ → α
l₂ u₂ : α → γ → β
h₁ : ∀ (b : β), GaloisConnection (l₁ b) (swap u b)
h₂ : ∀ (a : α), GaloisConnection (l₂ a) (u a)
⊢ sInf (image2 u s t) = u (sInf s) (sInf t)
state_after: no goals
tactic: simp_rw [sInf_image2, ← (h₂ _).u_sInf, ← (h₁ _).u_sInf]
Theorem: FintypeCat.toLightProfinite_obj_toTop_str_IsOpen
File: Mathlib/Topology/Category/LightProfinite/Basic.lean

Proof steps:
state_before: X✝ Y✝ : FintypeCat
f : X✝ ⟶ Y✝
⊢ Continuous f
state_after: no goals
tactic: continuity
Theorem: injective_algebraMap_of_linearMap
File: Mathlib/Algebra/Algebra/Basic.lean

Proof steps:
state_before: F : Type u_1
E : Type u_2
inst✝² : CommSemiring F
inst✝¹ : Semiring E
inst✝ : Algebra F E
b : F →ₗ[F] E
hb : Function.Injective ⇑b
x y : F
e : (algebraMap F E) x = (algebraMap F E) y
⊢ b x = b y
state_after: no goals
tactic: rw [← mul_one x, ← mul_one y, ← smul_eq_mul, ← smul_eq_mul,
    map_smul, map_smul, Algebra.smul_def, Algebra.smul_def, e]
Theorem: div_add_same
File: Mathlib/Algebra/Field/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
K : Type u_3
inst✝ : DivisionSemiring α
a b c d : α
h : b ≠ 0
⊢ (a + b) / b = a / b + 1
state_after: no goals
tactic: rw [← div_self h, add_div]
Theorem: Real.logb_le_logb_of_le
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

Proof steps:
state_before: b x y : ℝ
hb : 1 < b
h : 0 < x
hxy : x ≤ y
⊢ 0 < y
state_after: no goals
tactic: linarith
Theorem: stdSimplex_eq_inter
File: Mathlib/Analysis/Convex/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
ι : Type u_5
inst✝¹ : OrderedSemiring 𝕜
inst✝ : Fintype ι
⊢ stdSimplex 𝕜 ι = (⋂ x, {f | 0 ≤ f x}) ∩ {f | ∑ x : ι, f x = 1}
state_after: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
ι : Type u_5
inst✝¹ : OrderedSemiring 𝕜
inst✝ : Fintype ι
f : ι → 𝕜
⊢ f ∈ stdSimplex 𝕜 ι ↔ f ∈ (⋂ x, {f | 0 ≤ f x}) ∩ {f | ∑ x : ι, f x = 1}
tactic: ext f
state_before: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
ι : Type u_5
inst✝¹ : OrderedSemiring 𝕜
inst✝ : Fintype ι
f : ι → 𝕜
⊢ f ∈ stdSimplex 𝕜 ι ↔ f ∈ (⋂ x, {f | 0 ≤ f x}) ∩ {f | ∑ x : ι, f x = 1}
state_after: no goals
tactic: simp only [stdSimplex, Set.mem_inter_iff, Set.mem_iInter, Set.mem_setOf_eq]
Theorem: ProbabilityTheory.cond_eq_zero
File: Mathlib/Probability/ConditionalProbability.lean

Proof steps:
state_before: Ω : Type u_1
Ω' : Type u_2
α : Type u_3
m : MeasurableSpace Ω
m' : MeasurableSpace Ω'
μ : Measure Ω
s t : Set Ω
hμs : μ s ≠ ⊤
⊢ μ[|s] = 0 ↔ μ s = 0
state_after: no goals
tactic: simp [cond, hμs]
Theorem: CauSeq.lt_of_lt_of_eq
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
f g h : CauSeq α abs
fg : f < g
gh : g ≈ h
⊢ (h - f).Pos
state_after: case h.e'_3
α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
f g h : CauSeq α abs
fg : f < g
gh : g ≈ h
⊢ h - f = g - f + -(g - h)
tactic: convert pos_add_limZero fg (neg_limZero gh) using 1
state_before: case h.e'_3
α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
f g h : CauSeq α abs
fg : f < g
gh : g ≈ h
⊢ h - f = g - f + -(g - h)
state_after: no goals
tactic: simp
Theorem: UpperSemicontinuousAt.comp_continuousAt_of_eq
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 γ
inst✝⁵ : TopologicalSpace γ
inst✝⁴ : OrderTopology γ
δ : Type u_4
inst✝³ : LinearOrder δ
inst✝² : TopologicalSpace δ
inst✝¹ : OrderTopology δ
ι : Type u_5
inst✝ : TopologicalSpace ι
f : α → β
g : ι → α
y : α
x : ι
hf : UpperSemicontinuousAt f y
hg : ContinuousAt g x
hy : g x = y
⊢ UpperSemicontinuousAt (fun x => f (g x)) x
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 γ
inst✝⁵ : TopologicalSpace γ
inst✝⁴ : OrderTopology γ
δ : Type u_4
inst✝³ : LinearOrder δ
inst✝² : TopologicalSpace δ
inst✝¹ : OrderTopology δ
ι : Type u_5
inst✝ : TopologicalSpace ι
f : α → β
g : ι → α
y : α
x : ι
hf : UpperSemicontinuousAt f (g x)
hg : ContinuousAt g x
hy : g x = y
⊢ UpperSemicontinuousAt (fun x => f (g x)) x
tactic: rw [← hy] at hf
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 γ
inst✝⁵ : TopologicalSpace γ
inst✝⁴ : OrderTopology γ
δ : Type u_4
inst✝³ : LinearOrder δ
inst✝² : TopologicalSpace δ
inst✝¹ : OrderTopology δ
ι : Type u_5
inst✝ : TopologicalSpace ι
f : α → β
g : ι → α
y : α
x : ι
hf : UpperSemicontinuousAt f (g x)
hg : ContinuousAt g x
hy : g x = y
⊢ UpperSemicontinuousAt (fun x => f (g x)) x
state_after: no goals
tactic: exact comp_continuousAt hf hg
Theorem: MonoidHom.comp_one
File: Mathlib/Algebra/Group/Hom/Defs.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
H : Type u_8
F : Type u_9
inst✝⁴ : Group G
inst✝³ : CommGroup H
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
f : N →* P
⊢ f.comp 1 = 1
state_after: case h
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
H : Type u_8
F : Type u_9
inst✝⁴ : Group G
inst✝³ : CommGroup H
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
f : N →* P
x✝ : M
⊢ (f.comp 1) x✝ = 1 x✝
tactic: ext
state_before: case h
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
H : Type u_8
F : Type u_9
inst✝⁴ : Group G
inst✝³ : CommGroup H
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
f : N →* P
x✝ : M
⊢ (f.comp 1) x✝ = 1 x✝
state_after: no goals
tactic: simp only [map_one, coe_comp, Function.comp_apply, one_apply]
Theorem: mul_divp_cancel
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
inst✝ : Monoid α
a✝ b c a : α
u : αˣ
⊢ a * (↑u * ↑u⁻¹) = a
state_after: no goals
tactic: rw [Units.mul_inv, mul_one]
Theorem: IsMetricSeparated.finite_iUnion_right_iff
File: Mathlib/Topology/MetricSpace/MetricSeparated.lean

Proof steps:
state_before: X : Type u_1
inst✝ : EMetricSpace X
s✝ t✝ : Set X
x y : X
ι : Type u_2
I : Set ι
hI : I.Finite
s : Set X
t : ι → Set X
⊢ IsMetricSeparated s (⋃ i ∈ I, t i) ↔ ∀ i ∈ I, IsMetricSeparated s (t i)
state_after: no goals
tactic: simpa only [@comm _ _ s] using finite_iUnion_left_iff hI
Theorem: Homotopy.add_hom
File: Mathlib/Algebra/Homology/Homotopy.lean

Proof steps:
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i✝ : ι
f₁ g₁ f₂ g₂ : C ⟶ D
h₁ : Homotopy f₁ g₁
h₂ : Homotopy f₂ g₂
i j : ι
hij : ¬c.Rel j i
⊢ (h₁.hom + h₂.hom) i j = 0
state_after: no goals
tactic: rw [Pi.add_apply, Pi.add_apply, h₁.zero i j hij, h₂.zero i j hij, add_zero]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i✝ : ι
f₁ g₁ f₂ g₂ : C ⟶ D
h₁ : Homotopy f₁ g₁
h₂ : Homotopy f₂ g₂
i : ι
⊢ (f₁ + f₂).f i = (dNext i) (h₁.hom + h₂.hom) + (prevD i) (h₁.hom + h₂.hom) + (g₁ + g₂).f i
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i✝ : ι
f₁ g₁ f₂ g₂ : C ⟶ D
h₁ : Homotopy f₁ g₁
h₂ : Homotopy f₂ g₂
i : ι
⊢ (dNext i) h₁.hom + (prevD i) h₁.hom + g₁.f i + ((dNext i) h₂.hom + (prevD i) h₂.hom + g₂.f i) =
    (dNext i) h₁.hom + (dNext i) h₂.hom + ((prevD i) h₁.hom + (prevD i) h₂.hom) + (g₁.f i + g₂.f i)
tactic: simp only [HomologicalComplex.add_f_apply, h₁.comm, h₂.comm, AddMonoidHom.map_add]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i✝ : ι
f₁ g₁ f₂ g₂ : C ⟶ D
h₁ : Homotopy f₁ g₁
h₂ : Homotopy f₂ g₂
i : ι
⊢ (dNext i) h₁.hom + (prevD i) h₁.hom + g₁.f i + ((dNext i) h₂.hom + (prevD i) h₂.hom + g₂.f i) =
    (dNext i) h₁.hom + (dNext i) h₂.hom + ((prevD i) h₁.hom + (prevD i) h₂.hom) + (g₁.f i + g₂.f i)
state_after: no goals
tactic: abel
Theorem: Commensurable.commensurable_inv
File: Mathlib/GroupTheory/Commensurable.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
H : Subgroup G
g : ConjAct G
⊢ Commensurable (g • H) H ↔ Commensurable H (g⁻¹ • H)
state_after: no goals
tactic: rw [commensurable_conj, inv_smul_smul]
Theorem: BoxIntegral.integral_smul
File: Mathlib/Analysis/BoxIntegral/Basic.lean

Proof steps:
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c : ℝ
⊢ integral I l (fun x => c • f x) vol = c • integral I l f vol
state_after: case inl
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
⊢ integral I l (fun x => 0 • f x) vol = 0 • integral I l f vol

case inr
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c : ℝ
hc : c ≠ 0
⊢ integral I l (fun x => c • f x) vol = c • integral I l f vol
tactic: rcases eq_or_ne c 0 with (rfl | hc)
state_before: case inr
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c : ℝ
hc : c ≠ 0
⊢ integral I l (fun x => c • f x) vol = c • integral I l f vol
state_after: case pos
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c : ℝ
hc : c ≠ 0
hf : Integrable I l f vol
⊢ integral I l (fun x => c • f x) vol = c • integral I l f vol

case neg
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c : ℝ
hc : c ≠ 0
hf : ¬Integrable I l f vol
⊢ integral I l (fun x => c • f x) vol = c • integral I l f vol
tactic: by_cases hf : Integrable I l f vol
Theorem: CategoryTheory.isCoseparator_prod_of_isCoseparator_right
File: Mathlib/CategoryTheory/Generator.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms C
G H : C
inst✝ : HasBinaryProduct G H
hH : IsCoseparator H
⊢ {H} ⊆ {G, H}
state_after: no goals
tactic: simp
Theorem: CategoryTheory.PreGaloisCategory.autMap_apply_mul
File: Mathlib/CategoryTheory/Galois/GaloisObjects.lean

Proof steps:
state_before: C : Type u₁
inst✝⁴ : Category.{u₂, u₁} C
inst✝³ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝² : FiberFunctor F
A B : C
inst✝¹ : IsConnected A
inst✝ : IsGalois B
f : A ⟶ B
σ τ : Aut A
⊢ autMap f (σ * τ) = autMap f σ * autMap f τ
state_after: C : Type u₁
inst✝⁴ : Category.{u₂, u₁} C
inst✝³ : GaloisCategory C
F✝ : C ⥤ FintypeCat
inst✝² : FiberFunctor F✝
A B : C
inst✝¹ : IsConnected A
inst✝ : IsGalois B
f : A ⟶ B
σ τ : Aut A
F : C ⥤ FintypeCat := GaloisCategory.getFiberFunctor C
⊢ autMap f (σ * τ) = autMap f σ * autMap f τ
tactic: let F := GaloisCategory.getFiberFunctor C
state_before: C : Type u₁
inst✝⁴ : Category.{u₂, u₁} C
inst✝³ : GaloisCategory C
F✝ : C ⥤ FintypeCat
inst✝² : FiberFunctor F✝
A B : C
inst✝¹ : IsConnected A
inst✝ : IsGalois B
f : A ⟶ B
σ τ : Aut A
F : C ⥤ FintypeCat := GaloisCategory.getFiberFunctor C
⊢ autMap f (σ * τ) = autMap f σ * autMap f τ
state_after: case intro
C : Type u₁
inst✝⁴ : Category.{u₂, u₁} C
inst✝³ : GaloisCategory C
F✝ : C ⥤ FintypeCat
inst✝² : FiberFunctor F✝
A B : C
inst✝¹ : IsConnected A
inst✝ : IsGalois B
f : A ⟶ B
σ τ : Aut A
F : C ⥤ FintypeCat := GaloisCategory.getFiberFunctor C
a : ↑(F.obj A)
⊢ autMap f (σ * τ) = autMap f σ * autMap f τ
tactic: obtain ⟨a⟩ := nonempty_fiber_of_isConnected F A
state_before: case intro
C : Type u₁
inst✝⁴ : Category.{u₂, u₁} C
inst✝³ : GaloisCategory C
F✝ : C ⥤ FintypeCat
inst✝² : FiberFunctor F✝
A B : C
inst✝¹ : IsConnected A
inst✝ : IsGalois B
f : A ⟶ B
σ τ : Aut A
F : C ⥤ FintypeCat := GaloisCategory.getFiberFunctor C
a : ↑(F.obj A)
⊢ autMap f (σ * τ) = autMap f σ * autMap f τ
state_after: case intro.a
C : Type u₁
inst✝⁴ : Category.{u₂, u₁} C
inst✝³ : GaloisCategory C
F✝ : C ⥤ FintypeCat
inst✝² : FiberFunctor F✝
A B : C
inst✝¹ : IsConnected A
inst✝ : IsGalois B
f : A ⟶ B
σ τ : Aut A
F : C ⥤ FintypeCat := GaloisCategory.getFiberFunctor C
a : ↑(F.obj A)
⊢ (fun f_1 => F.map f_1.hom (F.map f a)) (autMap f (σ * τ)) =
    (fun f_1 => F.map f_1.hom (F.map f a)) (autMap f σ * autMap f τ)
tactic: apply evaluation_aut_injective_of_isConnected F (B : C) (F.map f a)
state_before: case intro.a
C : Type u₁
inst✝⁴ : Category.{u₂, u₁} C
inst✝³ : GaloisCategory C
F✝ : C ⥤ FintypeCat
inst✝² : FiberFunctor F✝
A B : C
inst✝¹ : IsConnected A
inst✝ : IsGalois B
f : A ⟶ B
σ τ : Aut A
F : C ⥤ FintypeCat := GaloisCategory.getFiberFunctor C
a : ↑(F.obj A)
⊢ (fun f_1 => F.map f_1.hom (F.map f a)) (autMap f (σ * τ)) =
    (fun f_1 => F.map f_1.hom (F.map f a)) (autMap f σ * autMap f τ)
state_after: no goals
tactic: simp [Aut.Aut_mul_def]