ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AddGroupTopology.toTopologicalSpace_injective
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝ : Group α
f g : GroupTopology α
h : f.toTopologicalSpace = g.toTopologicalSpace
⊢ f = g
state_after: case mk
G : Type w
H : Type x
α : Type u
β : Type v
inst✝ : Group α
g : GroupTopology α
toTopologicalSpace✝ : TopologicalSpace α
toTopologicalGroup✝ : TopologicalGroup α
h :
  { toTopologicalSpace := toTopologicalSpace✝, toTopologicalGroup := toTopologicalGroup✝ }.toTopologicalSpace =
    g.toTopologicalSpace
⊢ { toTopologicalSpace := toTopologicalSpace✝, toTopologicalGroup := toTopologicalGroup✝ } = g
tactic: cases f
state_before: case mk
G : Type w
H : Type x
α : Type u
β : Type v
inst✝ : Group α
g : GroupTopology α
toTopologicalSpace✝ : TopologicalSpace α
toTopologicalGroup✝ : TopologicalGroup α
h :
  { toTopologicalSpace := toTopologicalSpace✝, toTopologicalGroup := toTopologicalGroup✝ }.toTopologicalSpace =
    g.toTopologicalSpace
⊢ { toTopologicalSpace := toTopologicalSpace✝, toTopologicalGroup := toTopologicalGroup✝ } = g
state_after: case mk.mk
G : Type w
H : Type x
α : Type u
β : Type v
inst✝ : Group α
toTopologicalSpace✝¹ : TopologicalSpace α
toTopologicalGroup✝¹ : TopologicalGroup α
toTopologicalSpace✝ : TopologicalSpace α
toTopologicalGroup✝ : TopologicalGroup α
h :
  { toTopologicalSpace := toTopologicalSpace✝¹, toTopologicalGroup := toTopologicalGroup✝¹ }.toTopologicalSpace =
    { toTopologicalSpace := toTopologicalSpace✝, toTopologicalGroup := toTopologicalGroup✝ }.toTopologicalSpace
⊢ { toTopologicalSpace := toTopologicalSpace✝¹, toTopologicalGroup := toTopologicalGroup✝¹ } =
    { toTopologicalSpace := toTopologicalSpace✝, toTopologicalGroup := toTopologicalGroup✝ }
tactic: cases g
state_before: case mk.mk
G : Type w
H : Type x
α : Type u
β : Type v
inst✝ : Group α
toTopologicalSpace✝¹ : TopologicalSpace α
toTopologicalGroup✝¹ : TopologicalGroup α
toTopologicalSpace✝ : TopologicalSpace α
toTopologicalGroup✝ : TopologicalGroup α
h :
  { toTopologicalSpace := toTopologicalSpace✝¹, toTopologicalGroup := toTopologicalGroup✝¹ }.toTopologicalSpace =
    { toTopologicalSpace := toTopologicalSpace✝, toTopologicalGroup := toTopologicalGroup✝ }.toTopologicalSpace
⊢ { toTopologicalSpace := toTopologicalSpace✝¹, toTopologicalGroup := toTopologicalGroup✝¹ } =
    { toTopologicalSpace := toTopologicalSpace✝, toTopologicalGroup := toTopologicalGroup✝ }
state_after: no goals
tactic: congr
Theorem: Subsemigroup.coe_iSup_of_directed
File: Mathlib/Algebra/Group/Subsemigroup/Membership.lean

Proof steps:
state_before: ι : Sort u_1
M : Type u_2
A : Type u_3
B : Type u_4
inst✝ : Mul M
S : ι → Subsemigroup M
hS : Directed (fun x x_1 => x ≤ x_1) S
x : M
⊢ x ∈ ↑(⨆ i, S i) ↔ x ∈ ⋃ i, ↑(S i)
state_after: no goals
tactic: simp [mem_iSup_of_directed hS]
Theorem: LaurentSeries.ofPowerSeries_powerSeriesPart
File: Mathlib/RingTheory/LaurentSeries.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
x : LaurentSeries R
⊢ (ofPowerSeries ℤ R) x.powerSeriesPart = (single (-order x)) 1 * x
state_after: R : Type u_1
inst✝ : Semiring R
x : LaurentSeries R
⊢ (ofPowerSeries ℤ R) x.powerSeriesPart =
    (single (-order x)) 1 * ((single (order x)) 1 * (ofPowerSeries ℤ R) x.powerSeriesPart)
tactic: refine Eq.trans ?_ (congr rfl x.single_order_mul_powerSeriesPart)
state_before: R : Type u_1
inst✝ : Semiring R
x : LaurentSeries R
⊢ (ofPowerSeries ℤ R) x.powerSeriesPart =
    (single (-order x)) 1 * ((single (order x)) 1 * (ofPowerSeries ℤ R) x.powerSeriesPart)
state_after: no goals
tactic: rw [← mul_assoc, single_mul_single, neg_add_self, mul_one, ← C_apply, C_one, one_mul]
Theorem: Fin.succ_predAbove_succ
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
a : Fin n
b : Fin (n + 1)
⊢ a.succ.predAbove b.succ = (a.predAbove b).succ
state_after: case inl
n m : ℕ
a : Fin n
b : Fin (n + 1)
h : a.succ ≤ b
⊢ a.succ.predAbove b.succ = (a.predAbove b).succ

case inr
n m : ℕ
a : Fin n
b : Fin (n + 1)
h : b < a.succ
⊢ a.succ.predAbove b.succ = (a.predAbove b).succ
tactic: obtain h | h := Fin.le_or_lt (succ a) b
Theorem: Nat.smoothNumbers_one
File: Mathlib/NumberTheory/SmoothNumbers.lean

Proof steps:
state_before: ⊢ smoothNumbers 1 = {1}
state_after: no goals
tactic: simp (config := { decide := true }) only [not_false_eq_true, smoothNumbers_succ,
    smoothNumbers_zero]
Theorem: CategoryTheory.simplicialToCosimplicialAugmented_map_left
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ (CosimplicialObject.const Cᵒᵖ).map f.unop.right.op ≫ ((fun X => (unop X).rightOp) Y✝).hom =
    ((fun X => (unop X).rightOp) X✝).hom ≫ (𝟭 (CosimplicialObject Cᵒᵖ)).map (NatTrans.rightOp f.unop.left)
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategory
⊢ ((CosimplicialObject.const Cᵒᵖ).map f.unop.right.op ≫ ((fun X => (unop X).rightOp) Y✝).hom).app x =
    (((fun X => (unop X).rightOp) X✝).hom ≫ (𝟭 (CosimplicialObject Cᵒᵖ)).map (NatTrans.rightOp f.unop.left)).app x
tactic: ext x
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategory
⊢ ((CosimplicialObject.const Cᵒᵖ).map f.unop.right.op ≫ ((fun X => (unop X).rightOp) Y✝).hom).app x =
    (((fun X => (unop X).rightOp) X✝).hom ≫ (𝟭 (CosimplicialObject Cᵒᵖ)).map (NatTrans.rightOp f.unop.left)).app x
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategory
⊢ f.unop.right.op ≫ ((unop Y✝).hom.app (op x)).op = ((unop X✝).hom.app (op x)).op ≫ (f.unop.left.app (op x)).op
tactic: dsimp
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategory
⊢ f.unop.right.op ≫ ((unop Y✝).hom.app (op x)).op = ((unop X✝).hom.app (op x)).op ≫ (f.unop.left.app (op x)).op
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategory
⊢ ((unop Y✝).hom.app (op x) ≫ f.unop.right).op = (f.unop.left.app (op x) ≫ (unop X✝).hom.app (op x)).op
tactic: simp_rw [← op_comp]
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategory
⊢ ((unop Y✝).hom.app (op x) ≫ f.unop.right).op = (f.unop.left.app (op x) ≫ (unop X✝).hom.app (op x)).op
state_after: case h.e_f
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategory
⊢ (unop Y✝).hom.app (op x) ≫ f.unop.right = f.unop.left.app (op x) ≫ (unop X✝).hom.app (op x)
tactic: congr 1
state_before: case h.e_f
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategory
⊢ (unop Y✝).hom.app (op x) ≫ f.unop.right = f.unop.left.app (op x) ≫ (unop X✝).hom.app (op x)
state_after: no goals
tactic: exact (congr_app f.unop.w (op x)).symm
Theorem: Basis.abs_det_adjustToOrientation
File: Mathlib/LinearAlgebra/Orientation.lean

Proof steps:
state_before: R : Type u_1
inst✝⁵ : LinearOrderedCommRing R
M : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
ι : Type u_3
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
inst✝ : Nonempty ι
e : Basis ι R M
x : Orientation R M ι
v : ι → M
⊢ |(e.adjustToOrientation x).det v| = |e.det v|
state_after: no goals
tactic: cases' e.det_adjustToOrientation x with h h <;> simp [h]
Theorem: AlgebraicGeometry.IsAffineOpen.range_fromSpec
File: Mathlib/AlgebraicGeometry/AffineScheme.lean

Proof steps:
state_before: X Y : Scheme
U : X.Opens
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ Set.range ⇑hU.fromSpec.val.base = ↑U
state_after: X Y : Scheme
U : X.Opens
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ Set.range ⇑(Spec.map (X.presheaf.map (eqToHom ⋯).op) ≫ (↑U).isoSpec.inv ≫ U.ι).val.base = ↑U
tactic: delta IsAffineOpen.fromSpec
state_before: X Y : Scheme
U : X.Opens
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ Set.range ⇑(Spec.map (X.presheaf.map (eqToHom ⋯).op) ≫ (↑U).isoSpec.inv ≫ U.ι).val.base = ↑U
state_after: X Y : Scheme
U : X.Opens
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ Set.range ((⇑U.ι.val.base ∘ ⇑(↑U).isoSpec.inv.val.base) ∘ ⇑(Spec.map (X.presheaf.map (eqToHom ⋯).op)).val.base) = ↑U
tactic: dsimp
state_before: X Y : Scheme
U : X.Opens
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ Set.range ((⇑U.ι.val.base ∘ ⇑(↑U).isoSpec.inv.val.base) ∘ ⇑(Spec.map (X.presheaf.map (eqToHom ⋯).op)).val.base) = ↑U
state_after: X Y : Scheme
U : X.Opens
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ Set.range ⇑U.ι.val.base = ↑U

X Y : Scheme
U : X.Opens
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ Function.Surjective (⇑(↑U).isoSpec.inv.val.base ∘ ⇑(Spec.map (X.presheaf.map (eqToHom ⋯).op)).val.base)
tactic: rw [Function.comp.assoc, Set.range_comp, Set.range_iff_surjective.mpr, Set.image_univ]
state_before: X Y : Scheme
U : X.Opens
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ Function.Surjective (⇑(↑U).isoSpec.inv.val.base ∘ ⇑(Spec.map (X.presheaf.map (eqToHom ⋯).op)).val.base)
state_after: X Y : Scheme
U : X.Opens
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ Epi ((Spec.map (X.presheaf.map (eqToHom ⋯).op)).val.base ≫ (↑U).isoSpec.inv.val.base)
tactic: erw [← coe_comp, ← TopCat.epi_iff_surjective]
state_before: X Y : Scheme
U : X.Opens
hU : IsAffineOpen U
f : ↑Γ(X, U)
⊢ Epi ((Spec.map (X.presheaf.map (eqToHom ⋯).op)).val.base ≫ (↑U).isoSpec.inv.val.base)
state_after: no goals
tactic: infer_instance
Theorem: Polynomial.expand_pow
File: Mathlib/Algebra/Polynomial/Expand.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p q : ℕ
f : R[X]
⊢ (expand R (p ^ Nat.zero)) f = (⇑(expand R p))^[Nat.zero] f
state_after: no goals
tactic: rw [pow_zero, expand_one, Function.iterate_zero, id]
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p q : ℕ
f : R[X]
n : ℕ
ih : (expand R (p ^ n)) f = (⇑(expand R p))^[n] f
⊢ (expand R (p ^ n.succ)) f = (⇑(expand R p))^[n.succ] f
state_after: no goals
tactic: rw [Function.iterate_succ_apply', pow_succ', expand_mul, ih]
Theorem: MeasureTheory.Measure.measure_isAddInvariant_eq_smul_of_isCompact_closure
File: Mathlib/MeasureTheory/Measure/Haar/Unique.lean

Proof steps:
state_before: G : Type u_1
inst✝⁸ : TopologicalSpace G
inst✝⁷ : Group G
inst✝⁶ : TopologicalGroup G
inst✝⁵ : MeasurableSpace G
inst✝⁴ : BorelSpace G
inst✝³ : LocallyCompactSpace G
μ' μ : Measure G
inst✝² : μ.IsHaarMeasure
inst✝¹ : IsFiniteMeasureOnCompacts μ'
inst✝ : μ'.IsMulLeftInvariant
s : Set G
h's : IsCompact (closure s)
⊢ μ' s = μ'.haarScalarFactor μ • μ s
state_after: G : Type u_1
inst✝⁸ : TopologicalSpace G
inst✝⁷ : Group G
inst✝⁶ : TopologicalGroup G
inst✝⁵ : MeasurableSpace G
inst✝⁴ : BorelSpace G
inst✝³ : LocallyCompactSpace G
μ' μ : Measure G
inst✝² : μ.IsHaarMeasure
inst✝¹ : IsFiniteMeasureOnCompacts μ'
inst✝ : μ'.IsMulLeftInvariant
s : Set G
h's : IsCompact (closure s)
ν : Measure G := μ'.haarScalarFactor μ • μ
⊢ μ' s = μ'.haarScalarFactor μ • μ s
tactic: let ν := haarScalarFactor μ' μ • μ
state_before: G : Type u_1
inst✝⁸ : TopologicalSpace G
inst✝⁷ : Group G
inst✝⁶ : TopologicalGroup G
inst✝⁵ : MeasurableSpace G
inst✝⁴ : BorelSpace G
inst✝³ : LocallyCompactSpace G
μ' μ : Measure G
inst✝² : μ.IsHaarMeasure
inst✝¹ : IsFiniteMeasureOnCompacts μ'
inst✝ : μ'.IsMulLeftInvariant
s : Set G
h's : IsCompact (closure s)
ν : Measure G := μ'.haarScalarFactor μ • μ
⊢ μ' s = μ'.haarScalarFactor μ • μ s
state_after: case a
G : Type u_1
inst✝⁸ : TopologicalSpace G
inst✝⁷ : Group G
inst✝⁶ : TopologicalGroup G
inst✝⁵ : MeasurableSpace G
inst✝⁴ : BorelSpace G
inst✝³ : LocallyCompactSpace G
μ' μ : Measure G
inst✝² : μ.IsHaarMeasure
inst✝¹ : IsFiniteMeasureOnCompacts μ'
inst✝ : μ'.IsMulLeftInvariant
s : Set G
h's : IsCompact (closure s)
ν : Measure G := μ'.haarScalarFactor μ • μ
⊢ μ' s ≤ μ'.haarScalarFactor μ • μ s

case a
G : Type u_1
inst✝⁸ : TopologicalSpace G
inst✝⁷ : Group G
inst✝⁶ : TopologicalGroup G
inst✝⁵ : MeasurableSpace G
inst✝⁴ : BorelSpace G
inst✝³ : LocallyCompactSpace G
μ' μ : Measure G
inst✝² : μ.IsHaarMeasure
inst✝¹ : IsFiniteMeasureOnCompacts μ'
inst✝ : μ'.IsMulLeftInvariant
s : Set G
h's : IsCompact (closure s)
ν : Measure G := μ'.haarScalarFactor μ • μ
⊢ μ'.haarScalarFactor μ • μ s ≤ μ' s
tactic: apply le_antisymm
Theorem: Mathlib.Meta.Finset.insert_eq_cons
File: Mathlib/Tactic/NormNum/BigOperators.lean

Proof steps:
state_before: u v : Level
α : Type u_1
inst✝ : DecidableEq α
a : α
s : Finset α
h : a ∉ s
⊢ insert a s = Finset.cons a s h
state_after: case a
u v : Level
α : Type u_1
inst✝ : DecidableEq α
a : α
s : Finset α
h : a ∉ s
a✝ : α
⊢ a✝ ∈ insert a s ↔ a✝ ∈ Finset.cons a s h
tactic: ext
state_before: case a
u v : Level
α : Type u_1
inst✝ : DecidableEq α
a : α
s : Finset α
h : a ∉ s
a✝ : α
⊢ a✝ ∈ insert a s ↔ a✝ ∈ Finset.cons a s h
state_after: no goals
tactic: simp
Theorem: add_div'
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 a b c : α
hc : c ≠ 0
⊢ b + a / c = (b * c + a) / c
state_after: no goals
tactic: rw [add_div, mul_div_cancel_right₀ _ hc]
Theorem: padicValNat.maxPowDiv_eq_multiplicity_get
File: Mathlib/NumberTheory/Padics/PadicVal.lean

Proof steps:
state_before: p✝ p n : ℕ
hp : 1 < p
hn : 0 < n
h : multiplicity.Finite p n
⊢ p.maxPowDiv n = (multiplicity p n).get h
state_after: p✝ p n : ℕ
hp : 1 < p
hn : 0 < n
h : multiplicity.Finite p n
⊢ multiplicity p n = ↑(p.maxPowDiv n)
tactic: rw [PartENat.get_eq_iff_eq_coe.mpr]
state_before: p✝ p n : ℕ
hp : 1 < p
hn : 0 < n
h : multiplicity.Finite p n
⊢ multiplicity p n = ↑(p.maxPowDiv n)
state_after: no goals
tactic: apply maxPowDiv_eq_multiplicity hp hn|>.symm
Theorem: NumberField.inverse_basisMatrix_mulVec_eq_repr
File: Mathlib/NumberTheory/NumberField/EquivReindex.lean

Proof steps:
state_before: K : Type u_1
inst✝² : Field K
inst✝¹ : NumberField K
inst✝ : DecidableEq (K →+* ℂ)
α : 𝓞 K
i : K →+* ℂ
⊢ ((basisMatrix K)ᵀ⁻¹ *ᵥ fun j => (canonicalEmbedding K) ((algebraMap (𝓞 K) K) α) j) i =
    ↑((((integralBasis K).reindex (equivReindex K).symm).repr ↑α) i)
state_after: no goals
tactic: rw [inv_mulVec_eq_vec (canonicalEmbedding_eq_basisMatrix_mulVec ((algebraMap (𝓞 K) K) α))]
Theorem: IsLocalizedModule.fromLocalizedModule.surj
File: Mathlib/Algebra/Module/LocalizedModule.lean

Proof steps:
state_before: R : Type u_1
inst✝¹² : CommSemiring R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : AddCommMonoid M''
A : Type u_5
inst✝⁸ : CommSemiring A
inst✝⁷ : Algebra R A
inst✝⁶ : Module A M'
inst✝⁵ : IsLocalization S A
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M''
inst✝¹ : IsScalarTower R A M'
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
x : M'
m : M
s : ↥S
eq1 : (m, s).2 • x = f (m, s).1
⊢ (fromLocalizedModule S f) (LocalizedModule.mk m s) = x
state_after: no goals
tactic: rw [fromLocalizedModule_mk, Module.End_algebraMap_isUnit_inv_apply_eq_iff, ← eq1,
      Submonoid.smul_def]
Theorem: EReal.tendsto_nhds_bot_iff_real
File: Mathlib/Topology/Instances/EReal.lean

Proof steps:
state_before: α✝ : Type u_1
inst✝ : TopologicalSpace α✝
α : Type u_2
m : α → EReal
f : Filter α
⊢ (∀ (i : ℝ), True → ∀ᶠ (x : α) in f, m x ∈ Iio ↑i) ↔ ∀ (x : ℝ), ∀ᶠ (a : α) in f, m a < ↑x
state_after: no goals
tactic: simp only [true_implies, mem_Iio]
Theorem: Finsupp.equivMapDomain_trans'
File: Mathlib/Data/Finsupp/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
f : α ≃ β
g : β ≃ γ
⊢ equivMapDomain (f.trans g) = equivMapDomain g ∘ equivMapDomain f
state_after: case h.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
f : α ≃ β
g : β ≃ γ
x : α →₀ M
a✝ : γ
⊢ (equivMapDomain (f.trans g) x) a✝ = ((equivMapDomain g ∘ equivMapDomain f) x) a✝
tactic: ext x
state_before: case h.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
f : α ≃ β
g : β ≃ γ
x : α →₀ M
a✝ : γ
⊢ (equivMapDomain (f.trans g) x) a✝ = ((equivMapDomain g ∘ equivMapDomain f) x) a✝
state_after: no goals
tactic: rfl
Theorem: ProbabilityTheory.poissonPMFReal_pos
File: Mathlib/Probability/Distributions/Poisson.lean

Proof steps:
state_before: r : ℝ≥0
n : ℕ
hr : 0 < r
⊢ 0 < poissonPMFReal r n
state_after: r : ℝ≥0
n : ℕ
hr : 0 < r
⊢ 0 < rexp (-↑r) * ↑r ^ n / ↑n !
tactic: rw [poissonPMFReal]
state_before: r : ℝ≥0
n : ℕ
hr : 0 < r
⊢ 0 < rexp (-↑r) * ↑r ^ n / ↑n !
state_after: no goals
tactic: positivity
Theorem: Equiv.Perm.support_le_prod_of_mem
File: Mathlib/GroupTheory/Perm/Support.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
l : List (Perm α)
h : f ∈ l
hl : List.Pairwise Disjoint l
⊢ f.support ≤ l.prod.support
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
l : List (Perm α)
h : f ∈ l
hl : List.Pairwise Disjoint l
x : α
hx : x ∈ f.support
⊢ x ∈ l.prod.support
tactic: intro x hx
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
l : List (Perm α)
h : f ∈ l
hl : List.Pairwise Disjoint l
x : α
hx : x ∈ f.support
⊢ x ∈ l.prod.support
state_after: no goals
tactic: rwa [mem_support, ← eq_on_support_mem_disjoint h hl _ hx, ← mem_support]
Theorem: mul_nonpos_of_nonpos_of_nonneg
File: Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean

Proof steps:
state_before: α : Type u_1
a b c d : α
inst✝² : MulZeroClass α
inst✝¹ : Preorder α
inst✝ : MulPosMono α
ha : a ≤ 0
hb : 0 ≤ b
⊢ a * b ≤ 0
state_after: no goals
tactic: simpa only [zero_mul] using mul_le_mul_of_nonneg_right ha hb
Theorem: ProbabilityTheory.Kernel.indepSets_piiUnionInter_of_disjoint
File: Mathlib/Probability/Independence/Kernel.lean

Proof steps:
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝ : IsMarkovKernel κ
s : ι → Set (Set Ω)
S T : Set ι
h_indep : iIndepSets s κ μ
hST : Disjoint S T
⊢ IndepSets (piiUnionInter s S) (piiUnionInter s T) κ μ
state_after: case intro.intro.intro.intro.intro.intro.intro.intro
α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝ : IsMarkovKernel κ
s : ι → Set (Set Ω)
S T : Set ι
h_indep : iIndepSets s κ μ
hST : Disjoint S T
t1 t2 : Set Ω
p1 : Finset ι
hp1 : ↑p1 ⊆ S
f1 : ι → Set Ω
ht1_m : ∀ x ∈ p1, f1 x ∈ s x
ht1_eq : t1 = ⋂ x ∈ p1, f1 x
p2 : Finset ι
hp2 : ↑p2 ⊆ T
f2 : ι → Set Ω
ht2_m : ∀ x ∈ p2, f2 x ∈ s x
ht2_eq : t2 = ⋂ x ∈ p2, f2 x
⊢ ∀ᵐ (a : α) ∂μ, (κ a) (t1 ∩ t2) = (κ a) t1 * (κ a) t2
tactic: rintro t1 t2 ⟨p1, hp1, f1, ht1_m, ht1_eq⟩ ⟨p2, hp2, f2, ht2_m, ht2_eq⟩
Theorem: Equiv.Perm.exists_with_cycleType_iff
File: Mathlib/GroupTheory/Perm/Cycle/PossibleTypes.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
⊢ (∃ g, g.cycleType = m) ↔ m.sum ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a
state_after: case mp
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
⊢ (∃ g, g.cycleType = m) → m.sum ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a

case mpr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
m : Multiset ℕ
⊢ (m.sum ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) → ∃ g, g.cycleType = m
tactic: constructor
Theorem: Multiset.prod_eq_zero
File: Mathlib/Algebra/BigOperators/Ring/Multiset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : CommMonoidWithZero α
s : Multiset α
h : 0 ∈ s
⊢ s.prod = 0
state_after: case intro
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : CommMonoidWithZero α
s : Multiset α
h : 0 ∈ s
s' : Multiset α
hs' : s = 0 ::ₘ s'
⊢ s.prod = 0
tactic: rcases Multiset.exists_cons_of_mem h with ⟨s', hs'⟩
state_before: case intro
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : CommMonoidWithZero α
s : Multiset α
h : 0 ∈ s
s' : Multiset α
hs' : s = 0 ::ₘ s'
⊢ s.prod = 0
state_after: no goals
tactic: simp [hs', Multiset.prod_cons]
Theorem: toIcoMod_eq_fract_mul
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
p : α
hp : 0 < p
b : α
⊢ toIcoMod hp 0 b = Int.fract (b / p) * p
state_after: no goals
tactic: simp [toIcoMod_eq_add_fract_mul]
Theorem: CategoryTheory.presheafHom_isSheafFor
File: Mathlib/CategoryTheory/Sites/SheafHom.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝ : Category.{v', u'} A
F G : Cᵒᵖ ⥤ A
X : C
S : Sieve X
hG : ⦃Y : C⦄ → (f : Y ⟶ X) → IsLimit (G.mapCone (Sieve.pullback f S).arrows.cocone.op)
⊢ Presieve.IsSheafFor (presheafHom F G) S.arrows
state_after: C : Type u
inst✝¹ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝ : Category.{v', u'} A
F G : Cᵒᵖ ⥤ A
X : C
S : Sieve X
hG : ⦃Y : C⦄ → (f : Y ⟶ X) → IsLimit (G.mapCone (Sieve.pullback f S).arrows.cocone.op)
x : Presieve.FamilyOfElements (presheafHom F G) S.arrows
hx : x.Compatible
⊢ ∃! t, x.IsAmalgamation t
tactic: intro x hx
state_before: C : Type u
inst✝¹ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝ : Category.{v', u'} A
F G : Cᵒᵖ ⥤ A
X : C
S : Sieve X
hG : ⦃Y : C⦄ → (f : Y ⟶ X) → IsLimit (G.mapCone (Sieve.pullback f S).arrows.cocone.op)
x : Presieve.FamilyOfElements (presheafHom F G) S.arrows
hx : x.Compatible
⊢ ∃! t, x.IsAmalgamation t
state_after: case hex
C : Type u
inst✝¹ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝ : Category.{v', u'} A
F G : Cᵒᵖ ⥤ A
X : C
S : Sieve X
hG : ⦃Y : C⦄ → (f : Y ⟶ X) → IsLimit (G.mapCone (Sieve.pullback f S).arrows.cocone.op)
x : Presieve.FamilyOfElements (presheafHom F G) S.arrows
hx : x.Compatible
⊢ ∃ x_1, x.IsAmalgamation x_1

case hunique
C : Type u
inst✝¹ : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝ : Category.{v', u'} A
F G : Cᵒᵖ ⥤ A
X : C
S : Sieve X
hG : ⦃Y : C⦄ → (f : Y ⟶ X) → IsLimit (G.mapCone (Sieve.pullback f S).arrows.cocone.op)
x : Presieve.FamilyOfElements (presheafHom F G) S.arrows
hx : x.Compatible
⊢ ∀ (y₁ y₂ : (presheafHom F G).obj (op X)), x.IsAmalgamation y₁ → x.IsAmalgamation y₂ → y₁ = y₂
tactic: apply exists_unique_of_exists_of_unique
Theorem: disjoint_nhdsSet_nhds
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : RegularSpace X
x : X
s : Set X
⊢ Disjoint (𝓝ˢ s) (𝓝 x) ↔ x ∉ closure s
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : RegularSpace X
x : X
s : Set X
h : RegularSpace X ↔ ∀ (x : X) (s : Set X), Disjoint (𝓝ˢ s) (𝓝 x) ↔ x ∉ closure s
⊢ Disjoint (𝓝ˢ s) (𝓝 x) ↔ x ∉ closure s
tactic: have h := (regularSpace_TFAE X).out 0 2
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : RegularSpace X
x : X
s : Set X
h : RegularSpace X ↔ ∀ (x : X) (s : Set X), Disjoint (𝓝ˢ s) (𝓝 x) ↔ x ∉ closure s
⊢ Disjoint (𝓝ˢ s) (𝓝 x) ↔ x ∉ closure s
state_after: no goals
tactic: exact h.mp ‹_› _ _
Theorem: List.getElem?_indexOf
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : DecidableEq α
a : α
l : List α
h : a ∈ l
⊢ l[indexOf a l]? = some a
state_after: no goals
tactic: rw [getElem?_eq_getElem, getElem_indexOf (indexOf_lt_length.2 h)]
Theorem: Finsupp.card_toMultiset
File: Mathlib/Data/Finsupp/Multiset.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
f : α →₀ ℕ
⊢ Multiset.card (toMultiset f) = f.sum fun x => id
state_after: no goals
tactic: simp [toMultiset_apply, map_finsupp_sum, Function.id_def]