ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Matrix.IsDiag.fromBlocks
File: Mathlib/LinearAlgebra/Matrix/IsDiag.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R : Type u_3
n : Type u_4
m : Type u_5
inst✝ : Zero α
A : Matrix m m α
D : Matrix n n α
ha : A.IsDiag
hd : D.IsDiag
⊢ (Matrix.fromBlocks A 0 0 D).IsDiag
state_after: case inl.inl
α : Type u_1
β : Type u_2
R : Type u_3
n : Type u_4
m : Type u_5
inst✝ : Zero α
A : Matrix m m α
D : Matrix n n α
ha : A.IsDiag
hd : D.IsDiag
i j : m
hij : Sum.inl i ≠ Sum.inl j
⊢ Matrix.fromBlocks A 0 0 D (Sum.inl i) (Sum.inl j) = 0

case inl.inr
α : Type u_1
β : Type u_2
R : Type u_3
n : Type u_4
m : Type u_5
inst✝ : Zero α
A : Matrix m m α
D : Matrix n n α
ha : A.IsDiag
hd : D.IsDiag
i : m
j : n
hij : Sum.inl i ≠ Sum.inr j
⊢ Matrix.fromBlocks A 0 0 D (Sum.inl i) (Sum.inr j) = 0

case inr.inl
α : Type u_1
β : Type u_2
R : Type u_3
n : Type u_4
m : Type u_5
inst✝ : Zero α
A : Matrix m m α
D : Matrix n n α
ha : A.IsDiag
hd : D.IsDiag
i : n
j : m
hij : Sum.inr i ≠ Sum.inl j
⊢ Matrix.fromBlocks A 0 0 D (Sum.inr i) (Sum.inl j) = 0

case inr.inr
α : Type u_1
β : Type u_2
R : Type u_3
n : Type u_4
m : Type u_5
inst✝ : Zero α
A : Matrix m m α
D : Matrix n n α
ha : A.IsDiag
hd : D.IsDiag
i j : n
hij : Sum.inr i ≠ Sum.inr j
⊢ Matrix.fromBlocks A 0 0 D (Sum.inr i) (Sum.inr j) = 0
tactic: rintro (i | i) (j | j) hij
Theorem: Complex.sin_add_mul_I
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x✝ y✝ x y : ℂ
⊢ sin (x + y * I) = sin x * cosh y + cos x * sinh y * I
state_after: no goals
tactic: rw [sin_add, cos_mul_I, sin_mul_I, mul_assoc]
Theorem: HasStrictDerivAt.iterate
File: Mathlib/Analysis/Calculus/Deriv/Comp.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f✝ f₀ f₁ g : 𝕜 → F
f'✝ f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_1
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
s' t' : Set 𝕜'
h : 𝕜 → 𝕜'
h₁ : 𝕜 → 𝕜
h₂ : 𝕜' → 𝕜'
h' h₂' : 𝕜'
h₁' : 𝕜
g₁ : 𝕜' → F
g₁' : F
L' : Filter 𝕜'
y : 𝕜'
f : 𝕜 → 𝕜
f' : 𝕜
hf : HasStrictDerivAt f f' x
hx : f x = x
n : ℕ
⊢ HasStrictDerivAt f^[n] (f' ^ n) x
state_after: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f✝ f₀ f₁ g : 𝕜 → F
f'✝ f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_1
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
s' t' : Set 𝕜'
h : 𝕜 → 𝕜'
h₁ : 𝕜 → 𝕜
h₂ : 𝕜' → 𝕜'
h' h₂' : 𝕜'
h₁' : 𝕜
g₁ : 𝕜' → F
g₁' : F
L' : Filter 𝕜'
y : 𝕜'
f : 𝕜 → 𝕜
f' : 𝕜
hf : HasStrictDerivAt f f' x
hx : f x = x
n : ℕ
this : HasStrictFDerivAt f^[n] (smulRight 1 f' ^ n) x
⊢ HasStrictDerivAt f^[n] (f' ^ n) x
tactic: have := hf.iterate hx n
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f✝ f₀ f₁ g : 𝕜 → F
f'✝ f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_1
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
s' t' : Set 𝕜'
h : 𝕜 → 𝕜'
h₁ : 𝕜 → 𝕜
h₂ : 𝕜' → 𝕜'
h' h₂' : 𝕜'
h₁' : 𝕜
g₁ : 𝕜' → F
g₁' : F
L' : Filter 𝕜'
y : 𝕜'
f : 𝕜 → 𝕜
f' : 𝕜
hf : HasStrictDerivAt f f' x
hx : f x = x
n : ℕ
this : HasStrictFDerivAt f^[n] (smulRight 1 f' ^ n) x
⊢ HasStrictDerivAt f^[n] (f' ^ n) x
state_after: no goals
tactic: rwa [ContinuousLinearMap.smulRight_one_pow] at this
Theorem: List.iterate_add
File: Mathlib/Data/List/Iterate.lean

Proof steps:
state_before: α : Type u_1
f : α → α
a : α
m n : ℕ
⊢ iterate f a (m + n) = iterate f a m ++ iterate f (f^[m] a) n
state_after: no goals
tactic: induction m generalizing a with
  | zero => simp
  | succ n ih => rw [iterate, add_right_comm, iterate, ih, Nat.iterate, cons_append]
Theorem: CategoryTheory.Coverage.saturate_of_superset
File: Mathlib/CategoryTheory/Sites/Coverage.lean

Proof steps:
state_before: C : Type u_1
D : Type ?u.35289
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Category.{?u.35297, ?u.35289} D
K : Coverage C
X : C
S T : Sieve X
h : S ≤ T
hS : K.Saturate X S
⊢ K.Saturate X T
state_after: C : Type u_1
D : Type ?u.35289
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Category.{?u.35297, ?u.35289} D
K : Coverage C
X : C
S T : Sieve X
h : S ≤ T
hS : K.Saturate X S
⊢ ∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, S.arrows f → K.Saturate Y (Sieve.pullback f T)
tactic: apply Saturate.transitive _ _ _ hS
state_before: C : Type u_1
D : Type ?u.35289
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Category.{?u.35297, ?u.35289} D
K : Coverage C
X : C
S T : Sieve X
h : S ≤ T
hS : K.Saturate X S
⊢ ∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, S.arrows f → K.Saturate Y (Sieve.pullback f T)
state_after: C : Type u_1
D : Type ?u.35289
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Category.{?u.35297, ?u.35289} D
K : Coverage C
X : C
S T : Sieve X
h : S ≤ T
hS : K.Saturate X S
Y : C
g : Y ⟶ X
hg : S.arrows g
⊢ K.Saturate Y (Sieve.pullback g T)
tactic: intro Y g hg
state_before: C : Type u_1
D : Type ?u.35289
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Category.{?u.35297, ?u.35289} D
K : Coverage C
X : C
S T : Sieve X
h : S ≤ T
hS : K.Saturate X S
Y : C
g : Y ⟶ X
hg : S.arrows g
⊢ K.Saturate Y (Sieve.pullback g T)
state_after: C : Type u_1
D : Type ?u.35289
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Category.{?u.35297, ?u.35289} D
K : Coverage C
X : C
S T : Sieve X
h : S ≤ T
hS : K.Saturate X S
Y : C
g : Y ⟶ X
hg : S.arrows g
⊢ K.Saturate Y ⊤

case hf
C : Type u_1
D : Type ?u.35289
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Category.{?u.35297, ?u.35289} D
K : Coverage C
X : C
S T : Sieve X
h : S ≤ T
hS : K.Saturate X S
Y : C
g : Y ⟶ X
hg : S.arrows g
⊢ S.arrows g
tactic: rw [eq_top_pullback (h := h)]
Theorem: PrimeSpectrum.mem_compl_zeroLocus_iff_not_mem
File: Mathlib/RingTheory/PrimeSpectrum.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R
I : PrimeSpectrum R
⊢ I ∈ (zeroLocus {f})ᶜ ↔ f ∉ I.asIdeal
state_after: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R
I : PrimeSpectrum R
⊢ f ∉ ↑I.asIdeal ↔ f ∉ I.asIdeal
tactic: rw [Set.mem_compl_iff, mem_zeroLocus, Set.singleton_subset_iff]
state_before: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R
I : PrimeSpectrum R
⊢ f ∉ ↑I.asIdeal ↔ f ∉ I.asIdeal
state_after: no goals
tactic: rfl
Theorem: Part.to_unit_cont
File: Mathlib/Control/LawfulFix.lean

Proof steps:
state_before: α : Type u_1
β : α → Type u_2
f : Part α →o Part α
hc : Continuous f
x✝ : Chain (Unit → Part α)
⊢ (toUnitMono f) (ωSup x✝) = ωSup (x✝.map (toUnitMono f))
state_after: case h.unit
α : Type u_1
β : α → Type u_2
f : Part α →o Part α
hc : Continuous f
x✝ : Chain (Unit → Part α)
⊢ (toUnitMono f) (ωSup x✝) PUnit.unit = ωSup (x✝.map (toUnitMono f)) PUnit.unit
tactic: ext ⟨⟩ : 1
state_before: case h.unit
α : Type u_1
β : α → Type u_2
f : Part α →o Part α
hc : Continuous f
x✝ : Chain (Unit → Part α)
⊢ (toUnitMono f) (ωSup x✝) PUnit.unit = ωSup (x✝.map (toUnitMono f)) PUnit.unit
state_after: case h.unit
α : Type u_1
β : α → Type u_2
f : Part α →o Part α
hc : Continuous f
x✝ : Chain (Unit → Part α)
⊢ f (Part.ωSup (x✝.map (Pi.evalOrderHom PUnit.unit))) =
    Part.ωSup ((x✝.map (toUnitMono f)).map (Pi.evalOrderHom PUnit.unit))
tactic: dsimp [OmegaCompletePartialOrder.ωSup]
state_before: case h.unit
α : Type u_1
β : α → Type u_2
f : Part α →o Part α
hc : Continuous f
x✝ : Chain (Unit → Part α)
⊢ f (Part.ωSup (x✝.map (Pi.evalOrderHom PUnit.unit))) =
    Part.ωSup ((x✝.map (toUnitMono f)).map (Pi.evalOrderHom PUnit.unit))
state_after: case h.unit
α : Type u_1
β : α → Type u_2
f : Part α →o Part α
hc : Continuous f
x✝ : Chain (Unit → Part α)
⊢ ωSup (x✝.map (f.comp (Pi.evalOrderHom PUnit.unit))) = Part.ωSup (x✝.map (f.comp (Pi.evalOrderHom PUnit.unit)))
tactic: erw [hc, Chain.map_comp]
state_before: case h.unit
α : Type u_1
β : α → Type u_2
f : Part α →o Part α
hc : Continuous f
x✝ : Chain (Unit → Part α)
⊢ ωSup (x✝.map (f.comp (Pi.evalOrderHom PUnit.unit))) = Part.ωSup (x✝.map (f.comp (Pi.evalOrderHom PUnit.unit)))
state_after: no goals
tactic: rfl
Theorem: Hyperreal.infiniteNeg_mul_of_infinitePos_not_infinitesimal_neg
File: Mathlib/Data/Real/Hyperreal.lean

Proof steps:
state_before: x y : ℝ*
⊢ x.InfinitePos → ¬y.Infinitesimal → y < 0 → (x * y).InfiniteNeg
state_after: x y : ℝ*
⊢ x.InfinitePos → ¬(-y).Infinitesimal → 0 < -y → (x * -y).InfinitePos
tactic: rw [← infinitePos_neg, ← neg_pos, neg_mul_eq_mul_neg, ← infinitesimal_neg]
state_before: x y : ℝ*
⊢ x.InfinitePos → ¬(-y).Infinitesimal → 0 < -y → (x * -y).InfinitePos
state_after: no goals
tactic: exact infinitePos_mul_of_infinitePos_not_infinitesimal_pos
Theorem: Int.coprime_iff_nat_coprime
File: Mathlib/RingTheory/Int/Basic.lean

Proof steps:
state_before: a b : ℤ
⊢ IsCoprime a b ↔ a.natAbs.Coprime b.natAbs
state_after: no goals
tactic: rw [← gcd_eq_one_iff_coprime, Nat.coprime_iff_gcd_eq_one, gcd_eq_natAbs]
Theorem: MeasureTheory.SimpleFunc.range_comp_subset_range
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : β →ₛ γ
g : α → β
hgm : Measurable g
⊢ ↑(f.comp g hgm).range ⊆ ↑f.range
state_after: no goals
tactic: simp only [coe_range, coe_comp, Set.range_comp_subset_range]
Theorem: DFunLike.coe_fn_eq
File: Mathlib/Data/FunLike/Basic.lean

Proof steps:
state_before: F : Sort u_1
α : Sort u_2
β : α → Sort u_3
i : DFunLike F α β
f g : F
h : f = g
⊢ ⇑f = ⇑g
state_after: case refl
F : Sort u_1
α : Sort u_2
β : α → Sort u_3
i : DFunLike F α β
f : F
⊢ ⇑f = ⇑f
tactic: cases h
state_before: case refl
F : Sort u_1
α : Sort u_2
β : α → Sort u_3
i : DFunLike F α β
f : F
⊢ ⇑f = ⇑f
state_after: no goals
tactic: rfl
Theorem: _private.Mathlib.Combinatorics.SetFamily.CauchyDavenport.0.devosAddRel_iff
File: Mathlib/Combinatorics/SetFamily/CauchyDavenport.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Group α
inst✝ : DecidableEq α
x y : Finset α × Finset α
s t : Finset α
⊢ DevosMulRel x y ↔
    (x.1 * x.2).card < (y.1 * y.2).card ∨
      (x.1 * x.2).card = (y.1 * y.2).card ∧ y.1.card + y.2.card < x.1.card + x.2.card ∨
        (x.1 * x.2).card = (y.1 * y.2).card ∧ x.1.card + x.2.card = y.1.card + y.2.card ∧ x.1.card < y.1.card
state_after: no goals
tactic: simp [DevosMulRel, Prod.lex_iff, and_or_left]
Theorem: Relation.ReflTransGen.lift'
File: Mathlib/Logic/Relation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a✝ b✝ c d : α
p : β → β → Prop
a b : α
f : α → β
h : ∀ (a b : α), r a b → ReflTransGen p (f a) (f b)
hab : ReflTransGen r a b
⊢ ReflTransGen p (f a) (f b)
state_after: no goals
tactic: simpa [reflTransGen_idem] using hab.lift f h
Theorem: isClosed_setOf_specializes
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
inst✝ : R1Space X
x y : X
⊢ IsClosed {p | p.1 ⤳ p.2}
state_after: no goals
tactic: simp only [← isOpen_compl_iff, compl_setOf, ← disjoint_nhds_nhds_iff_not_specializes,
    isOpen_setOf_disjoint_nhds_nhds]
Theorem: ProbabilityTheory.setLIntegral_condKernel_eq_measure_prod
File: Mathlib/Probability/Kernel/Disintegration/Integral.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
κ : Kernel α (β × Ω)
inst✝ : IsFiniteKernel κ
f : β × Ω → ℝ≥0∞
a : α
s : Set β
hs : MeasurableSet s
t : Set Ω
ht : MeasurableSet t
⊢ ∫⁻ (b : β) in s, (κ.condKernel (a, b)) t ∂κ.fst a = (κ a) (s ×ˢ t)
state_after: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
κ : Kernel α (β × Ω)
inst✝ : IsFiniteKernel κ
f : β × Ω → ℝ≥0∞
a : α
s : Set β
hs : MeasurableSet s
t : Set Ω
ht : MeasurableSet t
this : (κ a) (s ×ˢ t) = ((κ.fst ⊗ₖ κ.condKernel) a) (s ×ˢ t)
⊢ ∫⁻ (b : β) in s, (κ.condKernel (a, b)) t ∂κ.fst a = (κ a) (s ×ˢ t)
tactic: have : κ a (s ×ˢ t) = (Kernel.fst κ ⊗ₖ Kernel.condKernel κ) a (s ×ˢ t) := by
    congr; exact (κ.disintegrate _).symm
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
κ : Kernel α (β × Ω)
inst✝ : IsFiniteKernel κ
f : β × Ω → ℝ≥0∞
a : α
s : Set β
hs : MeasurableSet s
t : Set Ω
ht : MeasurableSet t
this : (κ a) (s ×ˢ t) = ((κ.fst ⊗ₖ κ.condKernel) a) (s ×ˢ t)
⊢ ∫⁻ (b : β) in s, (κ.condKernel (a, b)) t ∂κ.fst a = (κ a) (s ×ˢ t)
state_after: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
κ : Kernel α (β × Ω)
inst✝ : IsFiniteKernel κ
f : β × Ω → ℝ≥0∞
a : α
s : Set β
hs : MeasurableSet s
t : Set Ω
ht : MeasurableSet t
this : (κ a) (s ×ˢ t) = ((κ.fst ⊗ₖ κ.condKernel) a) (s ×ˢ t)
⊢ ∫⁻ (b : β) in s, (κ.condKernel (a, b)) t ∂κ.fst a = ∫⁻ (b : β), (κ.condKernel (a, b)) {c | (b, c) ∈ s ×ˢ t} ∂κ.fst a
tactic: rw [this, Kernel.compProd_apply _ _ _ (hs.prod ht)]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
κ : Kernel α (β × Ω)
inst✝ : IsFiniteKernel κ
f : β × Ω → ℝ≥0∞
a : α
s : Set β
hs : MeasurableSet s
t : Set Ω
ht : MeasurableSet t
this : (κ a) (s ×ˢ t) = ((κ.fst ⊗ₖ κ.condKernel) a) (s ×ˢ t)
⊢ ∫⁻ (b : β) in s, (κ.condKernel (a, b)) t ∂κ.fst a = ∫⁻ (b : β), (κ.condKernel (a, b)) {c | (b, c) ∈ s ×ˢ t} ∂κ.fst a
state_after: no goals
tactic: classical
  have : ∀ b, Kernel.condKernel κ (a, b) {c | (b, c) ∈ s ×ˢ t}
      = s.indicator (fun b ↦ Kernel.condKernel κ (a, b) t) b := by
    intro b
    by_cases hb : b ∈ s <;> simp [hb]
  simp_rw [this]
  rw [lintegral_indicator _ hs]
Theorem: MulAction.stabilizer_finset_singleton
File: Mathlib/Algebra/Pointwise/Stabilizer.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
inst✝³ : Group G
inst✝² : Group H
inst✝¹ : MulAction G α
a : G
inst✝ : DecidableEq α
b : α
⊢ stabilizer G {b} = stabilizer G b
state_after: case h
G : Type u_1
H : Type u_2
α : Type u_3
inst✝³ : Group G
inst✝² : Group H
inst✝¹ : MulAction G α
a : G
inst✝ : DecidableEq α
b : α
x✝ : G
⊢ x✝ ∈ stabilizer G {b} ↔ x✝ ∈ stabilizer G b
tactic: ext
state_before: case h
G : Type u_1
H : Type u_2
α : Type u_3
inst✝³ : Group G
inst✝² : Group H
inst✝¹ : MulAction G α
a : G
inst✝ : DecidableEq α
b : α
x✝ : G
⊢ x✝ ∈ stabilizer G {b} ↔ x✝ ∈ stabilizer G b
state_after: no goals
tactic: simp
Theorem: Nat.WithBot.add_eq_two_iff
File: Mathlib/Data/Nat/WithBot.lean

Proof steps:
state_before: n m : WithBot ℕ
⊢ n + m = 2 ↔ n = 0 ∧ m = 2 ∨ n = 1 ∧ m = 1 ∨ n = 2 ∧ m = 0
state_after: case bot
m : WithBot ℕ
⊢ ⊥ + m = 2 ↔ ⊥ = 0 ∧ m = 2 ∨ ⊥ = 1 ∧ m = 1 ∨ ⊥ = 2 ∧ m = 0

case coe
m : WithBot ℕ
a✝ : ℕ
⊢ ↑a✝ + m = 2 ↔ ↑a✝ = 0 ∧ m = 2 ∨ ↑a✝ = 1 ∧ m = 1 ∨ ↑a✝ = 2 ∧ m = 0
tactic: cases n
state_before: case coe
m : WithBot ℕ
a✝ : ℕ
⊢ ↑a✝ + m = 2 ↔ ↑a✝ = 0 ∧ m = 2 ∨ ↑a✝ = 1 ∧ m = 1 ∨ ↑a✝ = 2 ∧ m = 0
state_after: case coe.bot
a✝ : ℕ
⊢ ↑a✝ + ⊥ = 2 ↔ ↑a✝ = 0 ∧ ⊥ = 2 ∨ ↑a✝ = 1 ∧ ⊥ = 1 ∨ ↑a✝ = 2 ∧ ⊥ = 0

case coe.coe
a✝¹ a✝ : ℕ
⊢ ↑a✝¹ + ↑a✝ = 2 ↔ ↑a✝¹ = 0 ∧ ↑a✝ = 2 ∨ ↑a✝¹ = 1 ∧ ↑a✝ = 1 ∨ ↑a✝¹ = 2 ∧ ↑a✝ = 0
tactic: cases m
state_before: case coe.coe
a✝¹ a✝ : ℕ
⊢ ↑a✝¹ + ↑a✝ = 2 ↔ ↑a✝¹ = 0 ∧ ↑a✝ = 2 ∨ ↑a✝¹ = 1 ∧ ↑a✝ = 1 ∨ ↑a✝¹ = 2 ∧ ↑a✝ = 0
state_after: no goals
tactic: simp [← WithBot.coe_add, Nat.add_eq_two_iff]
Theorem: LieAlgebra.IsKilling.ideal_eq_bot_of_isLieAbelian
File: Mathlib/Algebra/Lie/Killing.lean

Proof steps:
state_before: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : Field K
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
inst✝⁶ : LieAlgebra K L
inst✝⁵ : Module.Free R L
inst✝⁴ : Module.Finite R L
inst✝³ : IsKilling R L
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
I : LieIdeal R L
inst✝ : IsLieAbelian ↥↑I
⊢ I = ⊥
state_after: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : Field K
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
inst✝⁶ : LieAlgebra K L
inst✝⁵ : Module.Free R L
inst✝⁴ : Module.Finite R L
inst✝³ : IsKilling R L
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
I : LieIdeal R L
inst✝ : IsLieAbelian ↥↑I
⊢ I ≤ LieIdeal.killingCompl R L ⊤
tactic: rw [eq_bot_iff, ← killingCompl_top_eq_bot]
state_before: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : Field K
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
inst✝⁶ : LieAlgebra K L
inst✝⁵ : Module.Free R L
inst✝⁴ : Module.Finite R L
inst✝³ : IsKilling R L
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
I : LieIdeal R L
inst✝ : IsLieAbelian ↥↑I
⊢ I ≤ LieIdeal.killingCompl R L ⊤
state_after: no goals
tactic: exact I.le_killingCompl_top_of_isLieAbelian
Theorem: Subgroup.fg_iff_submonoid_fg
File: Mathlib/GroupTheory/Finiteness.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
inst✝³ : Monoid M
inst✝² : AddMonoid N
G : Type u_3
H : Type u_4
inst✝¹ : Group G
inst✝ : AddGroup H
P : Subgroup G
⊢ P.FG ↔ P.FG
state_after: case mp
M : Type u_1
N : Type u_2
inst✝³ : Monoid M
inst✝² : AddMonoid N
G : Type u_3
H : Type u_4
inst✝¹ : Group G
inst✝ : AddGroup H
P : Subgroup G
⊢ P.FG → P.FG

case mpr
M : Type u_1
N : Type u_2
inst✝³ : Monoid M
inst✝² : AddMonoid N
G : Type u_3
H : Type u_4
inst✝¹ : Group G
inst✝ : AddGroup H
P : Subgroup G
⊢ P.FG → P.FG
tactic: constructor
Theorem: Polynomial.natDegree_mul_C_le
File: Mathlib/Algebra/Polynomial/Degree/Lemmas.lean

Proof steps:
state_before: R : Type u
S : Type v
ι : Type w
a✝ b : R
m n : ℕ
inst✝ : Semiring R
p q r f : R[X]
a : R
⊢ f.natDegree + (C a).natDegree = f.natDegree + 0
state_after: no goals
tactic: rw [natDegree_C a]
Theorem: Prod.map_injective
File: Mathlib/Data/Prod/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : Nonempty α
inst✝ : Nonempty β
f : α → γ
g : β → δ
h : Injective (map f g)
a₁ a₂ : α
ha : f a₁ = f a₂
⊢ a₁ = a₂
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : Nonempty α
inst✝ : Nonempty β
f : α → γ
g : β → δ
h : Injective (map f g)
a₁ a₂ : α
ha : f a₁ = f a₂
inhabited_h : Inhabited β
⊢ a₁ = a₂
tactic: inhabit β
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : Nonempty α
inst✝ : Nonempty β
f : α → γ
g : β → δ
h : Injective (map f g)
a₁ a₂ : α
ha : f a₁ = f a₂
inhabited_h : Inhabited β
⊢ a₁ = a₂
state_after: no goals
tactic: injection
        @h (a₁, default) (a₂, default) (congr_arg (fun c : γ => Prod.mk c (g default)) ha : _)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : Nonempty α
inst✝ : Nonempty β
f : α → γ
g : β → δ
h : Injective (map f g)
b₁ b₂ : β
hb : g b₁ = g b₂
⊢ b₁ = b₂
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : Nonempty α
inst✝ : Nonempty β
f : α → γ
g : β → δ
h : Injective (map f g)
b₁ b₂ : β
hb : g b₁ = g b₂
inhabited_h : Inhabited α
⊢ b₁ = b₂
tactic: inhabit α
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : Nonempty α
inst✝ : Nonempty β
f : α → γ
g : β → δ
h : Injective (map f g)
b₁ b₂ : β
hb : g b₁ = g b₂
inhabited_h : Inhabited α
⊢ b₁ = b₂
state_after: no goals
tactic: injection @h (default, b₁) (default, b₂) (congr_arg (Prod.mk (f default)) hb : _)
Theorem: Mathlib.Tactic.Ring.smul_eq_cast
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₂ : R
a : ℕ
x✝¹ : ↑a = a'
x✝ : a' * b = c
⊢ a • b = c
state_after: 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₃ b b' b₁ b₂ b₃ c₁ c₂ : R
a : ℕ
⊢ a • b = ↑a * b
tactic: subst_vars
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₃ b b' b₁ b₂ b₃ c₁ c₂ : R
a : ℕ
⊢ a • b = ↑a * b
state_after: no goals
tactic: simp
Theorem: UniformConvexOn.neg
File: Mathlib/Analysis/Convex/Strong.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a b m : ℝ
x y : E
f g : E → ℝ
hf : UniformConvexOn s φ f
⊢ UniformConcaveOn s φ (-f)
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hf : UniformConvexOn s φ f
x : E
hx : x ∈ s
y : E
hy : y ∈ s
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ -(-f) (a • x + b • y) ≤ -(a • (-f) x + b • (-f) y + a * b * φ ‖x - y‖)
tactic: refine ⟨hf.1, fun x hx y hy a b ha hb hab ↦ le_of_neg_le_neg ?_⟩
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hf : UniformConvexOn s φ f
x : E
hx : x ∈ s
y : E
hy : y ∈ s
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ -(-f) (a • x + b • y) ≤ -(a • (-f) x + b • (-f) y + a * b * φ ‖x - y‖)
state_after: no goals
tactic: simpa [add_comm, -neg_le_neg_iff, le_sub_iff_add_le'] using hf.2 hx hy ha hb hab
Theorem: isCompact_univ_pi
File: Mathlib/Topology/Compactness/Compact.lean

Proof steps:
state_before: X✝ : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
s✝ t : Set X✝
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
s : (i : ι) → Set (X i)
h : ∀ (i : ι), IsCompact (s i)
⊢ IsCompact (univ.pi s)
state_after: case h.e'_3
X✝ : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
s✝ t : Set X✝
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
s : (i : ι) → Set (X i)
h : ∀ (i : ι), IsCompact (s i)
⊢ univ.pi s = {x | ∀ (i : ι), x i ∈ s i}
tactic: convert isCompact_pi_infinite h
state_before: case h.e'_3
X✝ : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
s✝ t : Set X✝
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
s : (i : ι) → Set (X i)
h : ∀ (i : ι), IsCompact (s i)
⊢ univ.pi s = {x | ∀ (i : ι), x i ∈ s i}
state_after: no goals
tactic: simp only [← mem_univ_pi, setOf_mem_eq]
Theorem: Finset.mem_uIcc'
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ a ∈ [[b, c]] ↔ b ≤ a ∧ a ≤ c ∨ c ≤ a ∧ a ≤ b
state_after: no goals
tactic: simp [uIcc_eq_union]