ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Mathlib.Tactic.Ring.sub_congr
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✝
R : Type u_2
inst✝ : Ring R
a a' b b' c : R
x✝² : a = a'
x✝¹ : b = b'
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₂ a₃ b b'✝ b₁ b₂ b₃ c c₁ c₂ : R✝
R : Type u_2
inst✝ : Ring R
a' b' : R
⊢ 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₂ a₃ b b'✝ b₁ b₂ b₃ c c₁ c₂ : R✝
R : Type u_2
inst✝ : Ring R
a' b' : R
⊢ a' - b' = a' - b'
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.memℒp_top_const
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
c : E
⊢ Memℒp (fun x => c) ⊤ μ
state_after: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
c : E
⊢ eLpNorm (fun x => c) ⊤ μ < ⊤
tactic: refine ⟨aestronglyMeasurable_const, ?_⟩
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
c : E
⊢ eLpNorm (fun x => c) ⊤ μ < ⊤
state_after: case pos
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
c : E
h : μ = 0
⊢ eLpNorm (fun x => c) ⊤ μ < ⊤

case neg
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
c : E
h : ¬μ = 0
⊢ eLpNorm (fun x => c) ⊤ μ < ⊤
tactic: by_cases h : μ = 0
Theorem: FirstOrder.Language.Substructure.mem_closure_iff_exists_term
File: Mathlib/ModelTheory/Substructures.lean

Proof steps:
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
s : Set M
x : M
⊢ x ∈ (closure L).toFun s ↔ ∃ t, Term.realize Subtype.val t = x
state_after: no goals
tactic: rw [← SetLike.mem_coe, coe_closure_eq_range_term_realize, mem_range]
Theorem: Filter.eventuallyConst_atTop_nat
File: Mathlib/Order/Filter/EventuallyConst.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f✝ : α → β
f : ℕ → α
⊢ EventuallyConst f atTop ↔ ∃ n, ∀ (m : ℕ), n ≤ m → f (m + 1) = f m
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f✝ : α → β
f : ℕ → α
⊢ (∃ i, ∀ (j : ℕ), i ≤ j → f j = f i) ↔ ∃ n, ∀ (m : ℕ), n ≤ m → f (m + 1) = f m
tactic: rw [eventuallyConst_atTop]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f✝ : α → β
f : ℕ → α
⊢ (∃ i, ∀ (j : ℕ), i ≤ j → f j = f i) ↔ ∃ n, ∀ (m : ℕ), n ≤ m → f (m + 1) = f m
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f✝ : α → β
f : ℕ → α
n : ℕ
h : ∀ (j : ℕ), n ≤ j → f j = f n
m : ℕ
hm : n ≤ m
⊢ f (m + 1) = f m

case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f✝ : α → β
f : ℕ → α
n : ℕ
h : ∀ (m : ℕ), n ≤ m → f (m + 1) = f m
m : ℕ
hm : n ≤ m
⊢ f m = f n
tactic: refine exists_congr fun n ↦ ⟨fun h m hm ↦ ?_, fun h m hm ↦ ?_⟩
Theorem: MulChar.ringHomComp_apply
File: Mathlib/NumberTheory/MulChar/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommMonoid R
R' : Type u_2
inst✝¹ : CommRing R'
R'' : Type u_3
inst✝ : CommRing R''
χ : MulChar R R'
f : R' →+* R''
a : R
ha : ¬IsUnit a
⊢ (↑{ toFun := fun a => f (χ a), map_one' := ⋯, map_mul' := ⋯ }).toFun a = 0
state_after: no goals
tactic: simp only [map_nonunit χ ha, map_zero]
Theorem: Prod.comul_comp_inr
File: Mathlib/RingTheory/Coalgebra/Basic.lean

Proof steps:
state_before: R : Type u
A : Type v
B : Type w
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : Module R A
inst✝² : Module R B
inst✝¹ : Coalgebra R A
inst✝ : Coalgebra R B
⊢ comul ∘ₗ inr R A B = TensorProduct.map (inr R A B) (inr R A B) ∘ₗ comul
state_after: case h
R : Type u
A : Type v
B : Type w
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : Module R A
inst✝² : Module R B
inst✝¹ : Coalgebra R A
inst✝ : Coalgebra R B
x✝ : B
⊢ (comul ∘ₗ inr R A B) x✝ = (TensorProduct.map (inr R A B) (inr R A B) ∘ₗ comul) x✝
tactic: ext
state_before: case h
R : Type u
A : Type v
B : Type w
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : Module R A
inst✝² : Module R B
inst✝¹ : Coalgebra R A
inst✝ : Coalgebra R B
x✝ : B
⊢ (comul ∘ₗ inr R A B) x✝ = (TensorProduct.map (inr R A B) (inr R A B) ∘ₗ comul) x✝
state_after: no goals
tactic: simp
Theorem: bernsteinPolynomial.eval_at_1
File: Mathlib/RingTheory/Polynomial/Bernstein.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
n ν : ℕ
⊢ Polynomial.eval 1 (bernsteinPolynomial R n ν) = if ν = n then 1 else 0
state_after: R : Type u_1
inst✝ : CommRing R
n ν : ℕ
⊢ Polynomial.eval 1 (↑(n.choose ν) * X ^ ν * (1 - X) ^ (n - ν)) = if ν = n then 1 else 0
tactic: rw [bernsteinPolynomial]
state_before: R : Type u_1
inst✝ : CommRing R
n ν : ℕ
⊢ Polynomial.eval 1 (↑(n.choose ν) * X ^ ν * (1 - X) ^ (n - ν)) = if ν = n then 1 else 0
state_after: case pos
R : Type u_1
inst✝ : CommRing R
n ν : ℕ
h : ν = n
⊢ Polynomial.eval 1 (↑(n.choose ν) * X ^ ν * (1 - X) ^ (n - ν)) = 1

case neg
R : Type u_1
inst✝ : CommRing R
n ν : ℕ
h : ¬ν = n
⊢ Polynomial.eval 1 (↑(n.choose ν) * X ^ ν * (1 - X) ^ (n - ν)) = 0
tactic: split_ifs with h
Theorem: SetTheory.PGame.mulOption_symm
File: Mathlib/SetTheory/Game/Basic.lean

Proof steps:
state_before: x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x.mulOption y i j⟧ = ⟦y.mulOption x j i⟧
state_after: x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x.moveLeft i * y⟧ + ⟦x * y.moveLeft j⟧ - ⟦x.moveLeft i * y.moveLeft j⟧ =
    ⟦y.moveLeft j * x⟧ + ⟦y * x.moveLeft i⟧ - ⟦y.moveLeft j * x.moveLeft i⟧
tactic: dsimp only [mulOption, quot_sub, quot_add]
state_before: x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x.moveLeft i * y⟧ + ⟦x * y.moveLeft j⟧ - ⟦x.moveLeft i * y.moveLeft j⟧ =
    ⟦y.moveLeft j * x⟧ + ⟦y * x.moveLeft i⟧ - ⟦y.moveLeft j * x.moveLeft i⟧
state_after: x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x * y.moveLeft j⟧ + ⟦x.moveLeft i * y⟧ - ⟦x.moveLeft i * y.moveLeft j⟧ =
    ⟦y.moveLeft j * x⟧ + ⟦y * x.moveLeft i⟧ - ⟦y.moveLeft j * x.moveLeft i⟧
tactic: rw [add_comm]
state_before: x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x * y.moveLeft j⟧ + ⟦x.moveLeft i * y⟧ - ⟦x.moveLeft i * y.moveLeft j⟧ =
    ⟦y.moveLeft j * x⟧ + ⟦y * x.moveLeft i⟧ - ⟦y.moveLeft j * x.moveLeft i⟧
state_after: case e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x * y.moveLeft j⟧ + ⟦x.moveLeft i * y⟧ = ⟦y.moveLeft j * x⟧ + ⟦y * x.moveLeft i⟧

case e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x.moveLeft i * y.moveLeft j⟧ = ⟦y.moveLeft j * x.moveLeft i⟧
tactic: congr 1
state_before: case e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x * y.moveLeft j⟧ + ⟦x.moveLeft i * y⟧ = ⟦y.moveLeft j * x⟧ + ⟦y * x.moveLeft i⟧

case e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x.moveLeft i * y.moveLeft j⟧ = ⟦y.moveLeft j * x.moveLeft i⟧
state_after: case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x * y.moveLeft j⟧ = ⟦y.moveLeft j * x⟧

case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x.moveLeft i * y⟧ = ⟦y * x.moveLeft i⟧

case e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x.moveLeft i * y.moveLeft j⟧ = ⟦y.moveLeft j * x.moveLeft i⟧
tactic: on_goal 1 => congr 1
state_before: case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x * y.moveLeft j⟧ = ⟦y.moveLeft j * x⟧

case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x.moveLeft i * y⟧ = ⟦y * x.moveLeft i⟧

case e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ ⟦x.moveLeft i * y.moveLeft j⟧ = ⟦y.moveLeft j * x.moveLeft i⟧
state_after: no goals
tactic: all_goals rw [quot_mul_comm]
Theorem: CategoryTheory.Limits.walkingParallelFamilyEquivWalkingParallelPair_functor_map
File: Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean

Proof steps:
state_before: J : Type w
C : Type u
inst✝ : Category.{v, u} C
X✝ Y : C
f : J → (X✝ ⟶ Y)
X : WalkingParallelFamily (ULift.{w, 0} Bool)
⊢ (𝟭 (WalkingParallelFamily (ULift.{w, 0} Bool))).obj X =
    ((parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right) ⋙
          parallelPair (line { down := true }) (line { down := false })).obj
      X
state_after: no goals
tactic: cases X <;> rfl
state_before: J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
⊢ ∀ {X Y : WalkingParallelFamily (ULift.{w, 0} Bool)} (f : X ⟶ Y),
    (𝟭 (WalkingParallelFamily (ULift.{w, 0} Bool))).map f ≫ ((fun X => eqToIso ⋯) Y).hom =
      ((fun X => eqToIso ⋯) X).hom ≫
        ((parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right) ⋙
              parallelPair (line { down := true }) (line { down := false })).map
          f
state_after: no goals
tactic: rintro _ _ (_|⟨_|_⟩) <;> aesop_cat
state_before: J : Type w
C : Type u
inst✝ : Category.{v, u} C
X✝ Y : C
f : J → (X✝ ⟶ Y)
X : WalkingParallelPair
⊢ (parallelPair (line { down := true }) (line { down := false }) ⋙
          parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).obj
      X =
    (𝟭 WalkingParallelPair).obj X
state_after: no goals
tactic: cases X <;> rfl
state_before: J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
⊢ ∀ {X Y : WalkingParallelPair} (f : X ⟶ Y),
    (parallelPair (line { down := true }) (line { down := false }) ⋙
              parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).map
          f ≫
        ((fun X => eqToIso ⋯) Y).hom =
      ((fun X => eqToIso ⋯) X).hom ≫ (𝟭 WalkingParallelPair).map f
state_after: no goals
tactic: rintro _ _ (_|_|_) <;> aesop_cat
state_before: J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
⊢ ∀ (X : WalkingParallelFamily (ULift.{w, 0} Bool)),
    (parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).map
          ((NatIso.ofComponents (fun X => eqToIso ⋯) ⋯).hom.app X) ≫
        (NatIso.ofComponents (fun X => eqToIso ⋯) ⋯).hom.app
          ((parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).obj
            X) =
      𝟙 ((parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).obj X)
state_after: no goals
tactic: rintro (_|_) <;> aesop_cat
Theorem: algebraMap_pos
File: Mathlib/Algebra/Order/Module/Algebra.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : OrderedCommSemiring α
inst✝² : StrictOrderedSemiring β
inst✝¹ : Algebra α β
inst✝ : SMulPosStrictMono α β
a a₁ a₂ : α
ha : 0 < a
⊢ 0 < (algebraMap α β) a
state_after: no goals
tactic: simpa using algebraMap_strictMono β ha
Theorem: ProbabilityTheory.Kernel.indep_iSup_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 κ
m : ι → MeasurableSpace Ω
h_le : ∀ (i : ι), m i ≤ _mΩ
h_indep : iIndep m κ μ
S T : Set ι
hST : Disjoint S T
⊢ Indep (⨆ i ∈ S, m i) (⨆ i ∈ T, m i) κ μ
state_after: case refine_1
α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝ : IsMarkovKernel κ
m : ι → MeasurableSpace Ω
h_le : ∀ (i : ι), m i ≤ _mΩ
h_indep : iIndep m κ μ
S T : Set ι
hST : Disjoint S T
⊢ IsPiSystem (piiUnionInter (fun n => {s | MeasurableSet s}) S)

case refine_2
α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝ : IsMarkovKernel κ
m : ι → MeasurableSpace Ω
h_le : ∀ (i : ι), m i ≤ _mΩ
h_indep : iIndep m κ μ
S T : Set ι
hST : Disjoint S T
⊢ IsPiSystem (piiUnionInter (fun n => {s | MeasurableSet s}) T)

case refine_3
α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝ : IsMarkovKernel κ
m : ι → MeasurableSpace Ω
h_le : ∀ (i : ι), m i ≤ _mΩ
h_indep : iIndep m κ μ
S T : Set ι
hST : Disjoint S T
⊢ IndepSets (piiUnionInter (fun n => {s | MeasurableSet s}) S) (piiUnionInter (fun n => {s | MeasurableSet s}) T) κ μ
tactic: refine
    IndepSets.indep (iSup₂_le fun i _ => h_le i) (iSup₂_le fun i _ => h_le i) ?_ ?_
      (generateFrom_piiUnionInter_measurableSet m S).symm
      (generateFrom_piiUnionInter_measurableSet m T).symm ?_
Theorem: IsLocalization.mk'_pow
File: Mathlib/RingTheory/Localization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x : R
y : ↥M
n : ℕ
⊢ mk' S (x ^ n) (y ^ n) = mk' S x y ^ n
state_after: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x : R
y : ↥M
n : ℕ
⊢ (algebraMap R S) x ^ n = (mk' S x y * (algebraMap R S) ↑y) ^ n
tactic: simp_rw [IsLocalization.mk'_eq_iff_eq_mul, SubmonoidClass.coe_pow, map_pow, ← mul_pow]
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x : R
y : ↥M
n : ℕ
⊢ (algebraMap R S) x ^ n = (mk' S x y * (algebraMap R S) ↑y) ^ n
state_after: no goals
tactic: simp
Theorem: GaussianInt.to_real_re
File: Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean

Proof steps:
state_before: x : ℤ[i]
⊢ ↑x.re = (toComplex x).re
state_after: no goals
tactic: simp [toComplex_def]
Theorem: MeasureTheory.Measure.restrict_iUnion_apply_ae
File: Mathlib/MeasureTheory/Measure/Restrict.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
inst✝ : Countable ι
s : ι → Set α
hd : Pairwise (AEDisjoint μ on s)
hm : ∀ (i : ι), NullMeasurableSet (s i) μ
t : Set α
ht : MeasurableSet t
⊢ (μ.restrict (⋃ i, s i)) t = ∑' (i : ι), (μ.restrict (s i)) t
state_after: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
inst✝ : Countable ι
s : ι → Set α
hd : Pairwise (AEDisjoint μ on s)
hm : ∀ (i : ι), NullMeasurableSet (s i) μ
t : Set α
ht : MeasurableSet t
⊢ μ (⋃ i, t ∩ s i) = ∑' (i : ι), μ (t ∩ s i)
tactic: simp only [restrict_apply, ht, inter_iUnion]
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ : Set α
inst✝ : Countable ι
s : ι → Set α
hd : Pairwise (AEDisjoint μ on s)
hm : ∀ (i : ι), NullMeasurableSet (s i) μ
t : Set α
ht : MeasurableSet t
⊢ μ (⋃ i, t ∩ s i) = ∑' (i : ι), μ (t ∩ s i)
state_after: no goals
tactic: exact
    measure_iUnion₀ (hd.mono fun i j h => h.mono inter_subset_right inter_subset_right)
      fun i => ht.nullMeasurableSet.inter (hm i)
Theorem: AddAction.mem_stabilizer_finset_iff_vadd_finset_subset
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 α
s : Finset α
⊢ a ∈ stabilizer G s ↔ a • s ⊆ s
state_after: no goals
tactic: rw [mem_stabilizer_iff, Finset.subset_iff_eq_of_card_le (Finset.card_smul_finset _ _).ge]
Theorem: BoxIntegral.Prepartition.biUnion_le_iff
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

Proof steps:
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi✝ πi₁ πi₂ πi : (J : Box ι) → Prepartition J
π' : Prepartition I
⊢ π.biUnion πi ≤ π' ↔ ∀ J ∈ π, πi J ≤ π'.restrict J
state_after: case mp
ι : Type u_1
I J✝ J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi✝ πi₁ πi₂ πi : (J : Box ι) → Prepartition J
π' : Prepartition I
H : π.biUnion πi ≤ π'
J : Box ι
hJ : J ∈ π
⊢ πi J ≤ π'.restrict J

case mpr
ι : Type u_1
I J✝ J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi✝ πi₁ πi₂ πi : (J : Box ι) → Prepartition J
π' : Prepartition I
H : ∀ J ∈ π, πi J ≤ π'.restrict J
J : Box ι
hJ : J ∈ π.biUnion πi
⊢ ∃ I' ∈ π', J ≤ I'
tactic: constructor <;> intro H J hJ
Theorem: CategoryTheory.Sieve.effectiveEpimorphic_family
File: Mathlib/CategoryTheory/Sites/EffectiveEpimorphic.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_3, u_1} C
B : C
α : Type u_2
X : α → C
π : (a : α) → X a ⟶ B
⊢ (Presieve.ofArrows X π).EffectiveEpimorphic ↔ EffectiveEpiFamily X π
state_after: case mp
C : Type u_1
inst✝ : Category.{u_3, u_1} C
B : C
α : Type u_2
X : α → C
π : (a : α) → X a ⟶ B
⊢ (Presieve.ofArrows X π).EffectiveEpimorphic → EffectiveEpiFamily X π

case mpr
C : Type u_1
inst✝ : Category.{u_3, u_1} C
B : C
α : Type u_2
X : α → C
π : (a : α) → X a ⟶ B
⊢ EffectiveEpiFamily X π → (Presieve.ofArrows X π).EffectiveEpimorphic
tactic: constructor
Theorem: Filter.HasBasis.to_image_id'
File: Mathlib/Order/Filter/Bases.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
h : l.HasBasis p s
x✝ : Set α
⊢ x✝ ∈ l ↔ ∃ i, (∃ i_1, p i_1 ∧ s i_1 = i) ∧ id i ⊆ x✝
state_after: no goals
tactic: simp [h.mem_iff]
Theorem: Finset.sum_eq_sum_iff_of_le
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : OrderedCancelCommMonoid M
f✝ g✝ : ι → M
s t : Finset ι
f g : ι → M
h : ∀ i ∈ s, f i ≤ g i
⊢ ∏ i ∈ s, f i = ∏ i ∈ s, g i ↔ ∀ i ∈ s, f i = g i
state_after: no goals
tactic: classical
    revert h
    refine Finset.induction_on s (fun _ ↦ ⟨fun _ _ h ↦ False.elim (Finset.not_mem_empty _ h),
      fun _ ↦ rfl⟩) fun a s ha ih H ↦ ?_
    specialize ih fun i ↦ H i ∘ Finset.mem_insert_of_mem
    rw [Finset.prod_insert ha, Finset.prod_insert ha, Finset.forall_mem_insert, ← ih]
    exact
      mul_eq_mul_iff_eq_and_eq (H a (s.mem_insert_self a))
        (Finset.prod_le_prod' fun i ↦ H i ∘ Finset.mem_insert_of_mem)
Theorem: CategoryTheory.Endofunctor.Coalgebra.equivOfNatIso_unitIso
File: Mathlib/CategoryTheory/Endofunctor/Algebra.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
F✝ : C ⥤ C
V V₀ V₁ V₂ : Coalgebra F✝
f : V₀ ⟶ V₁
g : V₁ ⟶ V₂
F G : C ⥤ C
α : F ≅ G
⊢ 𝟙 F = α.hom ≫ α.inv
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝ : Category.{v, u} C
F✝ : C ⥤ C
V V₀ V₁ V₂ : Coalgebra F✝
f : V₀ ⟶ V₁
g : V₁ ⟶ V₂
F G : C ⥤ C
α : F ≅ G
⊢ α.inv ≫ α.hom = 𝟙 G
state_after: no goals
tactic: simp
Theorem: LinearAlgebra.FreeProduct.lof_map_one
File: Mathlib/LinearAlgebra/FreeProduct/Basic.lean

Proof steps:
state_before: I : Type u
inst✝⁵ : DecidableEq I
i✝ : I
R : Type v
inst✝⁴ : CommSemiring R
A : I → Type w
inst✝³ : (i : I) → Semiring (A i)
inst✝² : (i : I) → Algebra R (A i)
B : Type w'
inst✝¹ : Semiring B
inst✝ : Algebra R B
maps : {i : I} → A i →ₐ[R] B
i : I
⊢ (lof R A i) 1 = 1
state_after: I : Type u
inst✝⁵ : DecidableEq I
i✝ : I
R : Type v
inst✝⁴ : CommSemiring R
A : I → Type w
inst✝³ : (i : I) → Semiring (A i)
inst✝² : (i : I) → Algebra R (A i)
B : Type w'
inst✝¹ : Semiring B
inst✝ : Algebra R B
maps : {i : I} → A i →ₐ[R] B
i : I
⊢ (ι' R A ∘ₗ DirectSum.lof R I A i) 1 = 1
tactic: rw [lof]
state_before: I : Type u
inst✝⁵ : DecidableEq I
i✝ : I
R : Type v
inst✝⁴ : CommSemiring R
A : I → Type w
inst✝³ : (i : I) → Semiring (A i)
inst✝² : (i : I) → Algebra R (A i)
B : Type w'
inst✝¹ : Semiring B
inst✝ : Algebra R B
maps : {i : I} → A i →ₐ[R] B
i : I
⊢ (ι' R A ∘ₗ DirectSum.lof R I A i) 1 = 1
state_after: I : Type u
inst✝⁵ : DecidableEq I
i✝ : I
R : Type v
inst✝⁴ : CommSemiring R
A : I → Type w
inst✝³ : (i : I) → Semiring (A i)
inst✝² : (i : I) → Algebra R (A i)
B : Type w'
inst✝¹ : Semiring B
inst✝ : Algebra R B
maps : {i : I} → A i →ₐ[R] B
i : I
⊢ (RingQuot.mkAlgHom R (rel R A)) ((ι R) ((DirectSum.lof R I A i) 1)) = 1
tactic: dsimp [mkAlgHom]
state_before: I : Type u
inst✝⁵ : DecidableEq I
i✝ : I
R : Type v
inst✝⁴ : CommSemiring R
A : I → Type w
inst✝³ : (i : I) → Semiring (A i)
inst✝² : (i : I) → Algebra R (A i)
B : Type w'
inst✝¹ : Semiring B
inst✝ : Algebra R B
maps : {i : I} → A i →ₐ[R] B
i : I
⊢ (RingQuot.mkAlgHom R (rel R A)) ((ι R) ((DirectSum.lof R I A i) 1)) = 1
state_after: no goals
tactic: exact identify_one R A i
Theorem: EReal.nhds_bot
File: Mathlib/Topology/Instances/EReal.lean

Proof steps:
state_before: α : Type u_1
inst✝ : TopologicalSpace α
⊢ ⨅ l, ⨅ (_ : ⊥ < l), 𝓟 (Iio l) = ⨅ a, ⨅ (_ : a ≠ ⊥), 𝓟 (Iio a)
state_after: no goals
tactic: simp only [bot_lt_iff_ne_bot]
Theorem: Prod.mk_covBy_mk_iff_right
File: Mathlib/Order/Cover.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
⊢ (a, b₁) ⋖ (a, b₂) ↔ b₁ ⋖ b₂
state_after: no goals
tactic: simp_rw [covBy_iff_wcovBy_and_lt, mk_wcovBy_mk_iff_right, mk_lt_mk_iff_right]
Theorem: exists_compact_iff_hasCompactMulSupport
File: Mathlib/Topology/Support.lean

Proof steps:
state_before: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace α'
inst✝³ : One β
inst✝² : One γ
inst✝¹ : One δ
g : β → γ
f : α → β
f₂ : α → γ
m : β → γ → δ
x : α
inst✝ : R1Space α
⊢ (∃ K, IsCompact K ∧ ∀ x ∉ K, f x = 1) ↔ HasCompactMulSupport f
state_after: no goals
tactic: simp_rw [← nmem_mulSupport, ← mem_compl_iff, ← subset_def, compl_subset_compl,
    hasCompactMulSupport_def, exists_isCompact_superset_iff]
Theorem: Finset.lt_sup_iff
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
a : α
⊢ a < s.sup f ↔ ∃ b ∈ s, a < f b
state_after: case mp
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
a : α
⊢ a < s.sup f → ∃ b ∈ s, a < f b

case mpr
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
a : α
⊢ (∃ b ∈ s, a < f b) → a < s.sup f
tactic: apply Iff.intro
Theorem: Real.log_neg_iff
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

Proof steps:
state_before: x y : ℝ
h : 0 < x
⊢ log x < 0 ↔ x < 1
state_after: x y : ℝ
h : 0 < x
⊢ log x < log 1 ↔ x < 1
tactic: rw [← log_one]
state_before: x y : ℝ
h : 0 < x
⊢ log x < log 1 ↔ x < 1
state_after: no goals
tactic: exact log_lt_log_iff h zero_lt_one