ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Order.mem_range_pred_of_not_isPredLimit
File: Mathlib/Order/SuccPred/Limit.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a b : α
C : α → Sort u_2
h : ¬IsPredLimit a
⊢ a ∈ range pred
state_after: case intro
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a b✝ : α
C : α → Sort u_2
h : ¬IsPredLimit a
b : α
hb : ¬IsMin b ∧ pred b = a
⊢ a ∈ range pred
tactic: cases' not_isPredLimit_iff.1 h with b hb
state_before: case intro
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a b✝ : α
C : α → Sort u_2
h : ¬IsPredLimit a
b : α
hb : ¬IsMin b ∧ pred b = a
⊢ a ∈ range pred
state_after: no goals
tactic: exact ⟨b, hb.2⟩
Theorem: Cardinal.zero_power_le
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
c : Cardinal.{u}
⊢ 0 ^ c ≤ 1
state_after: case pos
α β : Type u
c : Cardinal.{u}
h : c = 0
⊢ 0 ^ c ≤ 1

case neg
α β : Type u
c : Cardinal.{u}
h : ¬c = 0
⊢ 0 ^ c ≤ 1
tactic: by_cases h : c = 0
Theorem: Continuous.isOpenPosMeasure_map
File: Mathlib/MeasureTheory/Measure/OpenPos.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝⁷ : TopologicalSpace X
m : MeasurableSpace X
inst✝⁶ : TopologicalSpace Y
inst✝⁵ : T2Space Y
μ ν : Measure X
inst✝⁴ : μ.IsOpenPosMeasure
s U F : Set X
x : X
inst✝³ : OpensMeasurableSpace X
Z : Type u_3
inst✝² : TopologicalSpace Z
inst✝¹ : MeasurableSpace Z
inst✝ : BorelSpace Z
f : X → Z
hf : Continuous f
hf_surj : Surjective f
⊢ (map f μ).IsOpenPosMeasure
state_after: X : Type u_1
Y : Type u_2
inst✝⁷ : TopologicalSpace X
m : MeasurableSpace X
inst✝⁶ : TopologicalSpace Y
inst✝⁵ : T2Space Y
μ ν : Measure X
inst✝⁴ : μ.IsOpenPosMeasure
s U✝ F : Set X
x : X
inst✝³ : OpensMeasurableSpace X
Z : Type u_3
inst✝² : TopologicalSpace Z
inst✝¹ : MeasurableSpace Z
inst✝ : BorelSpace Z
f : X → Z
hf : Continuous f
hf_surj : Surjective f
U : Set Z
hUo : IsOpen U
hUne : U.Nonempty
⊢ (map f μ) U ≠ 0
tactic: refine ⟨fun U hUo hUne => ?_⟩
state_before: X : Type u_1
Y : Type u_2
inst✝⁷ : TopologicalSpace X
m : MeasurableSpace X
inst✝⁶ : TopologicalSpace Y
inst✝⁵ : T2Space Y
μ ν : Measure X
inst✝⁴ : μ.IsOpenPosMeasure
s U✝ F : Set X
x : X
inst✝³ : OpensMeasurableSpace X
Z : Type u_3
inst✝² : TopologicalSpace Z
inst✝¹ : MeasurableSpace Z
inst✝ : BorelSpace Z
f : X → Z
hf : Continuous f
hf_surj : Surjective f
U : Set Z
hUo : IsOpen U
hUne : U.Nonempty
⊢ (map f μ) U ≠ 0
state_after: X : Type u_1
Y : Type u_2
inst✝⁷ : TopologicalSpace X
m : MeasurableSpace X
inst✝⁶ : TopologicalSpace Y
inst✝⁵ : T2Space Y
μ ν : Measure X
inst✝⁴ : μ.IsOpenPosMeasure
s U✝ F : Set X
x : X
inst✝³ : OpensMeasurableSpace X
Z : Type u_3
inst✝² : TopologicalSpace Z
inst✝¹ : MeasurableSpace Z
inst✝ : BorelSpace Z
f : X → Z
hf : Continuous f
hf_surj : Surjective f
U : Set Z
hUo : IsOpen U
hUne : U.Nonempty
⊢ μ (f ⁻¹' U) ≠ 0
tactic: rw [Measure.map_apply hf.measurable hUo.measurableSet]
state_before: X : Type u_1
Y : Type u_2
inst✝⁷ : TopologicalSpace X
m : MeasurableSpace X
inst✝⁶ : TopologicalSpace Y
inst✝⁵ : T2Space Y
μ ν : Measure X
inst✝⁴ : μ.IsOpenPosMeasure
s U✝ F : Set X
x : X
inst✝³ : OpensMeasurableSpace X
Z : Type u_3
inst✝² : TopologicalSpace Z
inst✝¹ : MeasurableSpace Z
inst✝ : BorelSpace Z
f : X → Z
hf : Continuous f
hf_surj : Surjective f
U : Set Z
hUo : IsOpen U
hUne : U.Nonempty
⊢ μ (f ⁻¹' U) ≠ 0
state_after: no goals
tactic: exact (hUo.preimage hf).measure_ne_zero μ (hf_surj.nonempty_preimage.mpr hUne)
Theorem: Polynomial.eq_of_degree_le_of_eval_finset_eq
File: Mathlib/LinearAlgebra/Lagrange.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
s : Finset R
h_deg_le : f.degree ≤ ↑s.card
h_deg_eq : f.degree = g.degree
hlc : f.leadingCoeff = g.leadingCoeff
h_eval : ∀ x ∈ s, eval x f = eval x g
⊢ f = g
state_after: case inl
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
g : R[X]
s : Finset R
h_deg_le : degree 0 ≤ ↑s.card
h_deg_eq : degree 0 = g.degree
hlc : leadingCoeff 0 = g.leadingCoeff
h_eval : ∀ x ∈ s, eval x 0 = eval x g
⊢ 0 = g

case inr
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
s : Finset R
h_deg_le : f.degree ≤ ↑s.card
h_deg_eq : f.degree = g.degree
hlc : f.leadingCoeff = g.leadingCoeff
h_eval : ∀ x ∈ s, eval x f = eval x g
hf : f ≠ 0
⊢ f = g
tactic: rcases eq_or_ne f 0 with rfl | hf
Theorem: ProbabilityTheory.Kernel.setLIntegral_compProd_univ_left
File: Mathlib/Probability/Kernel/Composition.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → ℝ≥0∞
hf : Measurable f
t : Set γ
ht : MeasurableSet t
⊢ ∫⁻ (z : β × γ) in Set.univ ×ˢ t, f z ∂(κ ⊗ₖ η) a = ∫⁻ (x : β), ∫⁻ (y : γ) in t, f (x, y) ∂η (a, x) ∂κ a
state_after: no goals
tactic: simp_rw [setLIntegral_compProd κ η a hf MeasurableSet.univ ht, Measure.restrict_univ]
Theorem: StarModule.decomposeProdAdjoint_apply
File: Mathlib/Algebra/Star/Module.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝⁷ : Semiring R
inst✝⁶ : StarMul R
inst✝⁵ : TrivialStar R
inst✝⁴ : AddCommGroup A
inst✝³ : Module R A
inst✝² : StarAddMonoid A
inst✝¹ : StarModule R A
inst✝ : Invertible 2
⊢ A ≃ₗ[R] ↥(selfAdjoint A) × ↥(skewAdjoint A)
state_after: R : Type u_1
A : Type u_2
inst✝⁷ : Semiring R
inst✝⁶ : StarMul R
inst✝⁵ : TrivialStar R
inst✝⁴ : AddCommGroup A
inst✝³ : Module R A
inst✝² : StarAddMonoid A
inst✝¹ : StarModule R A
inst✝ : Invertible 2
⊢ (selfAdjointPart R).prod (skewAdjointPart R) ∘ₗ
      (selfAdjoint.submodule R A).subtype.coprod (skewAdjoint.submodule R A).subtype =
    LinearMap.id
tactic: refine LinearEquiv.ofLinear ((selfAdjointPart R).prod (skewAdjointPart R))
    (LinearMap.coprod ((selfAdjoint.submodule R A).subtype) (skewAdjoint.submodule R A).subtype)
    ?_ (LinearMap.ext <| StarModule.selfAdjointPart_add_skewAdjointPart R)
state_before: R : Type u_1
A : Type u_2
inst✝⁷ : Semiring R
inst✝⁶ : StarMul R
inst✝⁵ : TrivialStar R
inst✝⁴ : AddCommGroup A
inst✝³ : Module R A
inst✝² : StarAddMonoid A
inst✝¹ : StarModule R A
inst✝ : Invertible 2
⊢ (selfAdjointPart R).prod (skewAdjointPart R) ∘ₗ
      (selfAdjoint.submodule R A).subtype.coprod (skewAdjoint.submodule R A).subtype =
    LinearMap.id
state_after: no goals
tactic: ext x <;> dsimp <;> erw [Submodule.coeSubtype, Submodule.coeSubtype] <;> simp
Theorem: Matrix.fromRows_inj
File: Mathlib/Data/Matrix/ColumnRowPartitioned.lean

Proof steps:
state_before: R : Type u_1
m : Type u_2
m₁ : Type u_3
m₂ : Type u_4
n : Type u_5
n₁ : Type u_6
n₂ : Type u_7
inst✝¹¹ : Fintype m
inst✝¹⁰ : Fintype m₁
inst✝⁹ : Fintype m₂
inst✝⁸ : Fintype n
inst✝⁷ : Fintype n₁
inst✝⁶ : Fintype n₂
inst✝⁵ : DecidableEq m
inst✝⁴ : DecidableEq m₁
inst✝³ : DecidableEq m₂
inst✝² : DecidableEq n
inst✝¹ : DecidableEq n₁
inst✝ : DecidableEq n₂
⊢ Function.Injective2 fromRows
state_after: R : Type u_1
m : Type u_2
m₁ : Type u_3
m₂ : Type u_4
n : Type u_5
n₁ : Type u_6
n₂ : Type u_7
inst✝¹¹ : Fintype m
inst✝¹⁰ : Fintype m₁
inst✝⁹ : Fintype m₂
inst✝⁸ : Fintype n
inst✝⁷ : Fintype n₁
inst✝⁶ : Fintype n₂
inst✝⁵ : DecidableEq m
inst✝⁴ : DecidableEq m₁
inst✝³ : DecidableEq m₂
inst✝² : DecidableEq n
inst✝¹ : DecidableEq n₁
inst✝ : DecidableEq n₂
x1 x2 : Matrix m₁ n R
y1 y2 : Matrix m₂ n R
⊢ x1.fromRows y1 = x2.fromRows y2 → x1 = x2 ∧ y1 = y2
tactic: intros x1 x2 y1 y2
state_before: R : Type u_1
m : Type u_2
m₁ : Type u_3
m₂ : Type u_4
n : Type u_5
n₁ : Type u_6
n₂ : Type u_7
inst✝¹¹ : Fintype m
inst✝¹⁰ : Fintype m₁
inst✝⁹ : Fintype m₂
inst✝⁸ : Fintype n
inst✝⁷ : Fintype n₁
inst✝⁶ : Fintype n₂
inst✝⁵ : DecidableEq m
inst✝⁴ : DecidableEq m₁
inst✝³ : DecidableEq m₂
inst✝² : DecidableEq n
inst✝¹ : DecidableEq n₁
inst✝ : DecidableEq n₂
x1 x2 : Matrix m₁ n R
y1 y2 : Matrix m₂ n R
⊢ x1.fromRows y1 = x2.fromRows y2 → x1 = x2 ∧ y1 = y2
state_after: R : Type u_1
m : Type u_2
m₁ : Type u_3
m₂ : Type u_4
n : Type u_5
n₁ : Type u_6
n₂ : Type u_7
inst✝¹¹ : Fintype m
inst✝¹⁰ : Fintype m₁
inst✝⁹ : Fintype m₂
inst✝⁸ : Fintype n
inst✝⁷ : Fintype n₁
inst✝⁶ : Fintype n₂
inst✝⁵ : DecidableEq m
inst✝⁴ : DecidableEq m₁
inst✝³ : DecidableEq m₂
inst✝² : DecidableEq n
inst✝¹ : DecidableEq n₁
inst✝ : DecidableEq n₂
x1 x2 : Matrix m₁ n R
y1 y2 : Matrix m₂ n R
⊢ (∀ (i : m₁ ⊕ m₂) (j : n), x1.fromRows y1 i j = x2.fromRows y2 i j) →
    (∀ (i : m₁) (j : n), x1 i j = x2 i j) ∧ ∀ (i : m₂) (j : n), y1 i j = y2 i j
tactic: simp only [Function.funext_iff, ← Matrix.ext_iff]
state_before: R : Type u_1
m : Type u_2
m₁ : Type u_3
m₂ : Type u_4
n : Type u_5
n₁ : Type u_6
n₂ : Type u_7
inst✝¹¹ : Fintype m
inst✝¹⁰ : Fintype m₁
inst✝⁹ : Fintype m₂
inst✝⁸ : Fintype n
inst✝⁷ : Fintype n₁
inst✝⁶ : Fintype n₂
inst✝⁵ : DecidableEq m
inst✝⁴ : DecidableEq m₁
inst✝³ : DecidableEq m₂
inst✝² : DecidableEq n
inst✝¹ : DecidableEq n₁
inst✝ : DecidableEq n₂
x1 x2 : Matrix m₁ n R
y1 y2 : Matrix m₂ n R
⊢ (∀ (i : m₁ ⊕ m₂) (j : n), x1.fromRows y1 i j = x2.fromRows y2 i j) →
    (∀ (i : m₁) (j : n), x1 i j = x2 i j) ∧ ∀ (i : m₂) (j : n), y1 i j = y2 i j
state_after: no goals
tactic: aesop
Theorem: Rat.intCast_div
File: Mathlib/Data/Rat/Lemmas.lean

Proof steps:
state_before: a b : ℤ
h : b ∣ a
⊢ ↑(a / b) = ↑a / ↑b
state_after: case intro
b c : ℤ
⊢ ↑(b * c / b) = ↑(b * c) / ↑b
tactic: rcases h with ⟨c, rfl⟩
state_before: case intro
b c : ℤ
⊢ ↑(b * c / b) = ↑(b * c) / ↑b
state_after: no goals
tactic: rw [mul_comm b, Int.mul_ediv_assoc c (dvd_refl b), Int.cast_mul,
    intCast_div_self, Int.cast_mul, mul_div_assoc]
Theorem: Finset.Ioc_subset_Iic_self
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝ : LocallyFiniteOrderBot α
⊢ Ioc a b ⊆ Iic b
state_after: no goals
tactic: simpa [← coe_subset] using Set.Ioc_subset_Iic_self
Theorem: IsPGroup.of_card
File: Mathlib/GroupTheory/PGroup.lean

Proof steps:
state_before: p : ℕ
G : Type u_1
inst✝ : Group G
n : ℕ
hG : Nat.card G = p ^ n
g : G
⊢ g ^ p ^ n = 1
state_after: no goals
tactic: rw [← hG, pow_card_eq_one']
Theorem: PowerSeries.constantCoeff_invUnitsSub
File: Mathlib/RingTheory/PowerSeries/WellKnown.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝¹ : Ring R
inst✝ : Ring S
u : Rˣ
⊢ (constantCoeff R) (invUnitsSub u) = 1 /ₚ u
state_after: no goals
tactic: rw [← coeff_zero_eq_constantCoeff_apply, coeff_invUnitsSub, zero_add, pow_one]
Theorem: Matrix.dotProduct_stdBasis_eq_mul
File: Mathlib/LinearAlgebra/Matrix/DotProduct.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
p : Type u_3
R : Type u_4
inst✝² : Semiring R
inst✝¹ : Fintype n
inst✝ : DecidableEq n
v : n → R
c : R
i : n
⊢ v ⬝ᵥ (LinearMap.stdBasis R (fun x => R) i) c = v i * c
state_after: case h₀
m : Type u_1
n : Type u_2
p : Type u_3
R : Type u_4
inst✝² : Semiring R
inst✝¹ : Fintype n
inst✝ : DecidableEq n
v : n → R
c : R
i : n
⊢ ∀ b ∈ Finset.univ, b ≠ i → v b * (LinearMap.stdBasis R (fun x => R) i) c b = 0

case h₁
m : Type u_1
n : Type u_2
p : Type u_3
R : Type u_4
inst✝² : Semiring R
inst✝¹ : Fintype n
inst✝ : DecidableEq n
v : n → R
c : R
i : n
⊢ i ∉ Finset.univ → v i * (LinearMap.stdBasis R (fun x => R) i) c i = 0
tactic: rw [dotProduct, Finset.sum_eq_single i, LinearMap.stdBasis_same]
Theorem: SimpleGraph.deleteEdges_deleteEdges
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
H : SimpleGraph V
s✝ s₁ s₂ s s' : Set (Sym2 V)
⊢ (G.deleteEdges s).deleteEdges s' = G.deleteEdges (s ∪ s')
state_after: no goals
tactic: simp [deleteEdges, sdiff_sdiff]
Theorem: mulDissociated_empty
File: Mathlib/Combinatorics/Additive/Dissociation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CommGroup α
inst✝ : CommGroup β
s : Set α
t u : Finset α
d : ℕ
a : α
⊢ MulDissociated ∅
state_after: no goals
tactic: simp [MulDissociated, subset_empty_iff]
Theorem: exists_maximal_of_chains_bounded
File: Mathlib/Order/Zorn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
c : Set α
h : ∀ (c : Set α), IsChain r c → ∃ ub, ∀ a ∈ c, r a ub
trans : ∀ {a b c : α}, r a b → r b c → r a c
this✝ : ∃ ub, ∀ a ∈ maxChain r, r a ub
ub : α
hub : ∀ a ∈ maxChain r, r a ub
a : α
ha : r ub a
this : IsChain r (insert a (maxChain r))
⊢ a ∈ maxChain r
state_after: α : Type u_1
β : Type u_2
r : α → α → Prop
c : Set α
h : ∀ (c : Set α), IsChain r c → ∃ ub, ∀ a ∈ c, r a ub
trans : ∀ {a b c : α}, r a b → r b c → r a c
this✝ : ∃ ub, ∀ a ∈ maxChain r, r a ub
ub : α
hub : ∀ a ∈ maxChain r, r a ub
a : α
ha : r ub a
this : IsChain r (insert a (maxChain r))
⊢ a ∈ insert a (maxChain r)
tactic: rw [maxChain_spec.right this (subset_insert _ _)]
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
c : Set α
h : ∀ (c : Set α), IsChain r c → ∃ ub, ∀ a ∈ c, r a ub
trans : ∀ {a b c : α}, r a b → r b c → r a c
this✝ : ∃ ub, ∀ a ∈ maxChain r, r a ub
ub : α
hub : ∀ a ∈ maxChain r, r a ub
a : α
ha : r ub a
this : IsChain r (insert a (maxChain r))
⊢ a ∈ insert a (maxChain r)
state_after: no goals
tactic: exact mem_insert _ _
Theorem: CategoryTheory.Arrow.cechNerve_obj
File: Mathlib/AlgebraicTopology/CechNerve.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
f : Arrow C
inst✝ : ∀ (n : ℕ), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X✝ Y✝ : SimplexCategoryᵒᵖ
g : X✝ ⟶ Y✝
⊢ ∀ (j : Fin ((Opposite.unop Y✝).len + 1)),
    (fun i => WidePullback.π (fun x => f.hom) ((SimplexCategory.Hom.toOrderHom g.unop) i)) j ≫ f.hom =
      WidePullback.base fun x => f.hom
state_after: no goals
tactic: aesop_cat
Theorem: Ordinal.isLimit_iff_omega_dvd
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: a : Ordinal.{u_1}
⊢ a.IsLimit ↔ a ≠ 0 ∧ ω ∣ a
state_after: case refine_1
a : Ordinal.{u_1}
l : a.IsLimit
⊢ a ≤ ω * (a / ω)

case refine_2
a : Ordinal.{u_1}
h : a ≠ 0 ∧ ω ∣ a
⊢ a.IsLimit
tactic: refine ⟨fun l => ⟨l.1, ⟨a / ω, le_antisymm ?_ (mul_div_le _ _)⟩⟩, fun h => ?_⟩
Theorem: CategoryTheory.ShortComplex.HomotopyEquiv.refl_inv
File: Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.237910, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ₁ φ₂ φ₃ φ₄ : S₁ ⟶ S₂
S : ShortComplex C
⊢ 𝟙 S ≫ 𝟙 S = 𝟙 S
state_after: no goals
tactic: simp
state_before: C : Type u_1
inst✝¹ : Category.{?u.237910, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ₁ φ₂ φ₃ φ₄ : S₁ ⟶ S₂
S : ShortComplex C
⊢ 𝟙 S ≫ 𝟙 S = 𝟙 S
state_after: no goals
tactic: simp
Theorem: Equiv.optionSubtype_apply_symm_apply
File: Mathlib/Logic/Equiv/Option.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq β
x : β
e : { e // e none = x }
b : { y // y ≠ x }
⊢ some (((optionSubtype x) e).symm b) = (↑e).symm ↑b
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq β
x : β
e : { e // e none = x }
b : { y // y ≠ x }
⊢ some
      (({
              toFun := fun e =>
                { toFun := fun a => ⟨↑e (some a), ⋯⟩, invFun := fun b => ((↑e).symm ↑b).get ⋯, left_inv := ⋯,
                  right_inv := ⋯ },
              invFun := fun e =>
                ⟨{ toFun := fun a => a.casesOn' x (Subtype.val ∘ ⇑e),
                    invFun := fun b => if h : b = x then none else some (e.symm ⟨b, h⟩), left_inv := ⋯,
                    right_inv := ⋯ },
                  ⋯⟩,
              left_inv := ⋯, right_inv := ⋯ }
            e).symm
        b) =
    (↑e).symm ↑b
tactic: dsimp only [optionSubtype]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq β
x : β
e : { e // e none = x }
b : { y // y ≠ x }
⊢ some
      (({
              toFun := fun e =>
                { toFun := fun a => ⟨↑e (some a), ⋯⟩, invFun := fun b => ((↑e).symm ↑b).get ⋯, left_inv := ⋯,
                  right_inv := ⋯ },
              invFun := fun e =>
                ⟨{ toFun := fun a => a.casesOn' x (Subtype.val ∘ ⇑e),
                    invFun := fun b => if h : b = x then none else some (e.symm ⟨b, h⟩), left_inv := ⋯,
                    right_inv := ⋯ },
                  ⋯⟩,
              left_inv := ⋯, right_inv := ⋯ }
            e).symm
        b) =
    (↑e).symm ↑b
state_after: no goals
tactic: simp
Theorem: Matrix.zpow_add_of_nonpos
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

Proof steps:
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
m n : ℤ
hm : m ≤ 0
hn : n ≤ 0
⊢ A ^ (m + n) = A ^ m * A ^ n
state_after: case inl.intro
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
m n : ℤ
hm : m ≤ 0
hn : n ≤ 0
h : A⁻¹ * A = 1
right✝ : A * A⁻¹ = 1
⊢ A ^ (m + n) = A ^ m * A ^ n

case inr
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
m n : ℤ
hm : m ≤ 0
hn : n ≤ 0
h : A⁻¹ = 0
⊢ A ^ (m + n) = A ^ m * A ^ n
tactic: rcases nonsing_inv_cancel_or_zero A with (⟨h, _⟩ | h)
Theorem: schnirelmannDensity_finite
File: Mathlib/Combinatorics/Schnirelmann.lean

Proof steps:
state_before: A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
hA : A.Finite
⊢ schnirelmannDensity A = 0
state_after: no goals
tactic: simpa using schnirelmannDensity_finset hA.toFinset
Theorem: Equiv.Perm.support_one
File: Mathlib/GroupTheory/Perm/Support.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
⊢ support 1 = ∅
state_after: no goals
tactic: rw [support_eq_empty_iff]
Theorem: Polynomial.IsRoot.dvd
File: Mathlib/Algebra/Polynomial/Eval.lean

Proof steps:
state_before: R✝ : Type u
S : Type v
T : Type w
ι : Type y
a b : R✝
m n : ℕ
inst✝¹ : Semiring R✝
p✝ q✝ r : R✝[X]
x✝ : R✝
R : Type u_1
inst✝ : CommSemiring R
p q : R[X]
x : R
h : p.IsRoot x
hpq : p ∣ q
⊢ q.IsRoot x
state_after: no goals
tactic: rwa [IsRoot, eval, eval₂_eq_zero_of_dvd_of_eval₂_eq_zero _ _ hpq]
Theorem: LowerSet.sdiff_singleton
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : Preorder α
s✝ : LowerSet α
t : Set α
a✝ : α
s : LowerSet α
a : α
⊢ s.sdiff {a} = s.erase a
state_after: no goals
tactic: simp [sdiff, erase]
Theorem: BooleanRing.le_sup_inf_aux
File: Mathlib/Algebra/Ring/BooleanRing.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : BooleanRing α
inst✝¹ : BooleanRing β
inst✝ : BooleanRing γ
a b c : α
⊢ (a + b + a * b) * (a + c + a * c) =
    a * a + b * c + a * (b * c) + (a * b + a * a * b) + (a * c + a * a * c) + (a * b * c + a * a * b * c)
state_after: no goals
tactic: ring
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : BooleanRing α
inst✝¹ : BooleanRing β
inst✝ : BooleanRing γ
a b c : α
⊢ a * a + b * c + a * (b * c) + (a * b + a * a * b) + (a * c + a * a * c) + (a * b * c + a * a * b * c) =
    a + b * c + a * (b * c)
state_after: no goals
tactic: simp only [mul_self, add_self, add_zero]
Theorem: MvPolynomial.prod_X_pow_eq_monomial
File: Mathlib/Algebra/MvPolynomial/Basic.lean

Proof steps:
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
⊢ ∏ x ∈ s.support, X x ^ s x = (monomial s) 1
state_after: no goals
tactic: simp only [monomial_eq, map_one, one_mul, Finsupp.prod]
Theorem: Filter.tendsto_principal
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l✝ : Filter α
f : α → β
l : Filter α
s : Set β
⊢ Tendsto f l (𝓟 s) ↔ ∀ᶠ (a : α) in l, f a ∈ s
state_after: no goals
tactic: simp only [Tendsto, le_principal_iff, mem_map', Filter.Eventually]
Theorem: Finset.prod_Ico_add
File: Mathlib/Algebra/BigOperators/Intervals.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
inst✝³ : CommMonoid M
s₂ s₁ s : Finset α
a✝ : α
g f✝ : α → M
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
f : α → M
a b c : α
⊢ ∏ x ∈ Ico a b, f (c + x) = ∏ x ∈ Ico (a + c) (b + c), f x
state_after: case h.e'_2.a
α : Type u_1
M : Type u_2
inst✝³ : CommMonoid M
s₂ s₁ s : Finset α
a✝¹ : α
g f✝ : α → M
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
f : α → M
a b c x✝ : α
a✝ : x✝ ∈ Ico a b
⊢ f (c + x✝) = f (x✝ + c)
tactic: convert prod_Ico_add' f a b c using 2
state_before: case h.e'_2.a
α : Type u_1
M : Type u_2
inst✝³ : CommMonoid M
s₂ s₁ s : Finset α
a✝¹ : α
g f✝ : α → M
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
f : α → M
a b c x✝ : α
a✝ : x✝ ∈ Ico a b
⊢ f (c + x✝) = f (x✝ + c)
state_after: no goals
tactic: rw [add_comm]
Theorem: CategoryTheory.equivEssImageOfReflective_map_counitIso_app_hom
File: Mathlib/CategoryTheory/Adjunction/Reflective.lean

Proof steps:
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
inst✝ : Reflective i
X : i.EssImageSubcategory
⊢ i.essImageInclusion.map (equivEssImageOfReflective_counitIso_app X).hom = inv ((reflectorAdjunction i).unit.app X.obj)
state_after: C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
inst✝ : Reflective i
X : i.EssImageSubcategory
⊢ inv ((reflectorAdjunction i).unit.app X.obj) = inv ((reflectorAdjunction i).unit.app X.obj)
tactic: simp only [Functor.comp_obj, Functor.essImageInclusion_obj, Functor.toEssImage_obj_obj,
      equivEssImageOfReflective_counitIso_app, asIso, Iso.symm_mk, Functor.essImageInclusion_map,
      Functor.id_obj]
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
inst✝ : Reflective i
X : i.EssImageSubcategory
⊢ inv ((reflectorAdjunction i).unit.app X.obj) = inv ((reflectorAdjunction i).unit.app X.obj)
state_after: no goals
tactic: rfl
Theorem: MulAction.aestabilizer_coe
File: Mathlib/MeasureTheory/Group/AEStabilizer.lean

Proof steps:
state_before: G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
x✝ : MeasurableSpace α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
s : Set α
⊢ 1 ∈ { carrier := {g | g • s =ᶠ[ae μ] s}, mul_mem' := ⋯ }.carrier
state_after: no goals
tactic: simp
state_before: G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
x✝ : MeasurableSpace α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
s : Set α
g₁ g₂ : G
h₁ : g₁ ∈ {g | g • s =ᶠ[ae μ] s}
h₂ : g₂ ∈ {g | g • s =ᶠ[ae μ] s}
⊢ g₁ * g₂ ∈ {g | g • s =ᶠ[ae μ] s}
state_after: no goals
tactic: simpa only [smul_smul] using ((smul_set_ae_eq g₁).2 h₂).trans h₁
state_before: G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
x✝ : MeasurableSpace α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
s : Set α
g : G
h : g ∈ { carrier := {g | g • s =ᶠ[ae μ] s}, mul_mem' := ⋯, one_mem' := ⋯ }.carrier
⊢ g⁻¹ ∈ { carrier := {g | g • s =ᶠ[ae μ] s}, mul_mem' := ⋯, one_mem' := ⋯ }.carrier
state_after: no goals
tactic: simpa using (smul_set_ae_eq g⁻¹).2 h.out.symm
Theorem: Nat.not_even_bit1
File: Mathlib/Algebra/Ring/Parity.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
m n✝ n : ℕ
⊢ ¬Even (2 * n + 1)
state_after: no goals
tactic: simp [parity_simps]
Theorem: Surreal.Multiplication.P4_neg_right
File: Mathlib/SetTheory/Surreal/Multiplication.lean

Proof steps:
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
⊢ P4 x₁ x₂ y ↔ P4 x₁ x₂ (-y)
state_after: no goals
tactic: rw [P4, P4, neg_neg, and_comm]
Theorem: Nat.cast_add_choose
File: Mathlib/Data/Nat/Choose/Cast.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : DivisionRing K
inst✝ : CharZero K
a b : ℕ
⊢ ↑((a + b).choose a) = ↑(a + b)! / (↑a ! * ↑b !)
state_after: no goals
tactic: rw [cast_choose K (_root_.le_add_right le_rfl), add_tsub_cancel_left]