1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: isOpen_prod_iff
File: Mathlib/Topology/Constructions.lean

tactic: simp_rw [Prod.forall, mem_nhds_prod_iff', and_left_comm]
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : TopologicalSpace W
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
s : Set (X × Y)
⊢ (∀ x ∈ s, s ∈ 𝓝 x) ↔ ∀ (a : X) (b : Y), (a, b) ∈ s → ∃ u v, IsOpen u ∧ IsOpen v ∧ a ∈ u ∧ b ∈ v ∧ u ×ˢ v ⊆ s
state_after: no goals
Theorem: CategoryTheory.Limits.IsZero.of_mono_eq_zero
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

tactic: subst h
state_before: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : Mono f
h : f = 0
⊢ IsZero X
state_after: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : Mono 0
⊢ IsZero X

tactic: apply of_mono_zero X Y
state_before: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : Mono 0
⊢ IsZero X
state_after: no goals
Theorem: Hyperreal.infinitePos_of_tendsto_top
File: Mathlib/Data/Real/Hyperreal.lean

tactic: simp only [Set.compl_setOf, not_lt]
state_before: f : ℕ → ℝ
hf : Tendsto f atTop atTop
r : ℝ
hf' : ∀ (b : ℝ), ∃ i, ∀ (a : ℕ), i ≤ a → b ≤ f a
i : ℕ
hi : ∀ (a : ℕ), i ≤ a → r + 1 ≤ f a
hi' : ∀ (a : ℕ), f a < r + 1 → a < i
⊢ {a | r < f a}ᶜ ⊆ {a | a ≤ i}
state_after: f : ℕ → ℝ
hf : Tendsto f atTop atTop
r : ℝ
hf' : ∀ (b : ℝ), ∃ i, ∀ (a : ℕ), i ≤ a → b ≤ f a
i : ℕ
hi : ∀ (a : ℕ), i ≤ a → r + 1 ≤ f a
hi' : ∀ (a : ℕ), f a < r + 1 → a < i
⊢ {a | f a ≤ r} ⊆ {a | a ≤ i}

tactic: exact fun a har => le_of_lt (hi' a (lt_of_le_of_lt har (lt_add_one _)))
state_before: f : ℕ → ℝ
hf : Tendsto f atTop atTop
r : ℝ
hf' : ∀ (b : ℝ), ∃ i, ∀ (a : ℕ), i ≤ a → b ≤ f a
i : ℕ
hi : ∀ (a : ℕ), i ≤ a → r + 1 ≤ f a
hi' : ∀ (a : ℕ), f a < r + 1 → a < i
⊢ {a | f a ≤ r} ⊆ {a | a ≤ i}
state_after: no goals
Theorem: MeasureTheory.L1.integral_eq_setToL1
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [integral]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
f : ↥(Lp E 1 μ)
⊢ integral f = (setToL1 ⋯) f
state_after: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
f : ↥(Lp E 1 μ)
⊢ integralCLM f = (setToL1 ⋯) f

tactic: rfl
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
f : ↥(Lp E 1 μ)
⊢ integralCLM f = (setToL1 ⋯) f
state_after: no goals
Theorem: Polynomial.coeff_zero_eq_eval_zero
File: Mathlib/Algebra/Polynomial/Eval.lean

tactic: simp
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
p : R[X]
⊢ p.coeff 0 = p.coeff 0 * 0 ^ 0
state_after: no goals

tactic: symm
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
p : R[X]
⊢ p.coeff 0 * 0 ^ 0 = eval 0 p
state_after: 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
p : R[X]
⊢ eval 0 p = p.coeff 0 * 0 ^ 0

tactic: rw [eval_eq_sum]
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
p : R[X]
⊢ eval 0 p = p.coeff 0 * 0 ^ 0
state_after: 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
p : R[X]
⊢ (p.sum fun e a => a * 0 ^ e) = p.coeff 0 * 0 ^ 0

tactic: exact Finset.sum_eq_single _ (fun b _ hb => by simp [zero_pow hb]) (by simp)
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
p : R[X]
⊢ (p.sum fun e a => a * 0 ^ e) = p.coeff 0 * 0 ^ 0
state_after: no goals

tactic: simp [zero_pow hb]
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
p : R[X]
b : ℕ
x✝ : b ∈ p.support
hb : b ≠ 0
⊢ (fun e a => a * 0 ^ e) b (p.coeff b) = 0
state_after: no goals

tactic: simp
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
p : R[X]
⊢ 0 ∉ p.support → (fun e a => a * 0 ^ e) 0 (p.coeff 0) = 0
state_after: no goals
Theorem: AlgebraicGeometry.RingedSpace.basicOpen_mul
File: Mathlib/Geometry/RingedSpace/Basic.lean

tactic: ext1
state_before: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f g : ↑(X.presheaf.obj { unop := U })
⊢ X.basicOpen (f * g) = X.basicOpen f ⊓ X.basicOpen g
state_after: case h
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f g : ↑(X.presheaf.obj { unop := U })
⊢ ↑(X.basicOpen (f * g)) = ↑(X.basicOpen f ⊓ X.basicOpen g)

tactic: dsimp [RingedSpace.basicOpen]
state_before: case h
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f g : ↑(X.presheaf.obj { unop := U })
⊢ ↑(X.basicOpen (f * g)) = ↑(X.basicOpen f ⊓ X.basicOpen g)
state_after: case h
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f g : ↑(X.presheaf.obj { unop := U })
⊢ Subtype.val '' {x | IsUnit ((X.presheaf.germ x) (f * g))} =
    Subtype.val '' {x | IsUnit ((X.presheaf.germ x) f)} ∩ Subtype.val '' {x | IsUnit ((X.presheaf.germ x) g)}

tactic: rw [← Set.image_inter Subtype.coe_injective]
state_before: case h
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f g : ↑(X.presheaf.obj { unop := U })
⊢ Subtype.val '' {x | IsUnit ((X.presheaf.germ x) (f * g))} =
    Subtype.val '' {x | IsUnit ((X.presheaf.germ x) f)} ∩ Subtype.val '' {x | IsUnit ((X.presheaf.germ x) g)}
state_after: case h
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f g : ↑(X.presheaf.obj { unop := U })
⊢ Subtype.val '' {x | IsUnit ((X.presheaf.germ x) (f * g))} =
    (fun a => ↑a) '' ({x | IsUnit ((X.presheaf.germ x) f)} ∩ {x | IsUnit ((X.presheaf.germ x) g)})

tactic: ext x
state_before: case h
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f g : ↑(X.presheaf.obj { unop := U })
⊢ Subtype.val '' {x | IsUnit ((X.presheaf.germ x) (f * g))} =
    (fun a => ↑a) '' ({x | IsUnit ((X.presheaf.germ x) f)} ∩ {x | IsUnit ((X.presheaf.germ x) g)})
state_after: case h.h
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f g : ↑(X.presheaf.obj { unop := U })
x : ↑↑X.toPresheafedSpace
⊢ x ∈ Subtype.val '' {x | IsUnit ((X.presheaf.germ x) (f * g))} ↔
    x ∈ (fun a => ↑a) '' ({x | IsUnit ((X.presheaf.germ x) f)} ∩ {x | IsUnit ((X.presheaf.germ x) g)})

tactic: simp [map_mul, Set.mem_image]
state_before: case h.h
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f g : ↑(X.presheaf.obj { unop := U })
x : ↑↑X.toPresheafedSpace
⊢ x ∈ Subtype.val '' {x | IsUnit ((X.presheaf.germ x) (f * g))} ↔
    x ∈ (fun a => ↑a) '' ({x | IsUnit ((X.presheaf.germ x) f)} ∩ {x | IsUnit ((X.presheaf.germ x) g)})
state_after: no goals
Theorem: not_summable_iff_tendsto_nat_atTop_of_nonneg
File: Mathlib/Topology/Algebra/InfiniteSum/Real.lean

tactic: lift f to ℕ → ℝ≥0 using hf
state_before: α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
f✝ : ℕ → α
a : α
f : ℕ → ℝ
hf : ∀ (n : ℕ), 0 ≤ f n
⊢ ¬Summable f ↔ Tendsto (fun n => ∑ i ∈ range n, f i) atTop atTop
state_after: case intro
α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
f✝ : ℕ → α
a : α
f : ℕ → ℝ≥0
⊢ (¬Summable fun i => ↑(f i)) ↔ Tendsto (fun n => ∑ i ∈ range n, (fun i => ↑(f i)) i) atTop atTop

tactic: exact mod_cast NNReal.not_summable_iff_tendsto_nat_atTop
state_before: case intro
α : Type u_1
β : Type u_2
inst✝ : PseudoMetricSpace α
f✝ : ℕ → α
a : α
f : ℕ → ℝ≥0
⊢ (¬Summable fun i => ↑(f i)) ↔ Tendsto (fun n => ∑ i ∈ range n, (fun i => ↑(f i)) i) atTop atTop
state_after: no goals
Theorem: Computation.LiftRel.equiv
File: Mathlib/Data/Seq/Computation.lean

tactic: apply LiftRel.symm
state_before: α : Type u
β : Type v
γ : Type w
R : α → α → Prop
refl : ∀ (x : α), R x x
symm : ∀ {x y : α}, R x y → R y x
trans : ∀ {x y z : α}, R x y → R y z → R x z
⊢ ∀ {x y : Computation α}, LiftRel R x y → LiftRel R y x
state_after: case H
α : Type u
β : Type v
γ : Type w
R : α → α → Prop
refl : ∀ (x : α), R x x
symm : ∀ {x y : α}, R x y → R y x
trans : ∀ {x y z : α}, R x y → R y z → R x z
⊢ Symmetric R

tactic: apply symm
state_before: case H
α : Type u
β : Type v
γ : Type w
R : α → α → Prop
refl : ∀ (x : α), R x x
symm : ∀ {x y : α}, R x y → R y x
trans : ∀ {x y z : α}, R x y → R y z → R x z
⊢ Symmetric R
state_after: no goals

tactic: apply LiftRel.trans
state_before: α : Type u
β : Type v
γ : Type w
R : α → α → Prop
refl : ∀ (x : α), R x x
symm : ∀ {x y : α}, R x y → R y x
trans : ∀ {x y z : α}, R x y → R y z → R x z
⊢ ∀ {x y z : Computation α}, LiftRel R x y → LiftRel R y z → LiftRel R x z
state_after: case H
α : Type u
β : Type v
γ : Type w
R : α → α → Prop
refl : ∀ (x : α), R x x
symm : ∀ {x y : α}, R x y → R y x
trans : ∀ {x y z : α}, R x y → R y z → R x z
⊢ Transitive R

tactic: apply trans
state_before: case H
α : Type u
β : Type v
γ : Type w
R : α → α → Prop
refl : ∀ (x : α), R x x
symm : ∀ {x y : α}, R x y → R y x
trans : ∀ {x y z : α}, R x y → R y z → R x z
⊢ Transitive R
state_after: no goals
Theorem: SMulCommClass.of_commMonoid
File: Mathlib/Algebra/Group/Action/Defs.lean

tactic: rw [← one_smul G (s • x), ← smul_assoc, ← one_smul G x, ← smul_assoc s 1 x,
  smul_comm, smul_assoc, one_smul, smul_assoc, one_smul]
state_before: M : Type u_1
N : Type u_2
G✝ : Type u_3
A✝ : Type u_4
B✝ : Type u_5
α : Type u_6
β : Type u_7
γ : Type u_8
δ : Type u_9
inst✝⁶ : Monoid M
inst✝⁵ : MulAction M α
A : Type u_10
B : Type u_11
G : Type u_12
inst✝⁴ : CommMonoid G
inst✝³ : SMul A G
inst✝² : SMul B G
inst✝¹ : IsScalarTower A G G
inst✝ : IsScalarTower B G G
r : A
s : B
x : G
⊢ r • s • x = s • r • x
state_after: no goals
Theorem: String.all_iff
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: simp [all_eq]
state_before: s : String
p : Char → Bool
⊢ s.all p = true ↔ ∀ (c : Char), c ∈ s.data → p c = true
state_after: no goals
Theorem: NonUnitalAlgHom.toAlgHom_zero
File: Mathlib/Algebra/Algebra/Unitization.lean

tactic: ext
state_before: S : Type u_1
R : Type u_2
A : Type u_3
inst✝¹² : CommSemiring S
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : NonUnitalSemiring A
inst✝⁹ : Module R A
inst✝⁸ : SMulCommClass R A A
inst✝⁷ : IsScalarTower R A A
B : Type u_4
inst✝⁶ : Semiring B
inst✝⁵ : Algebra S B
inst✝⁴ : Algebra S R
inst✝³ : DistribMulAction S A
inst✝² : IsScalarTower S R A
C : Type u_5
inst✝¹ : Semiring C
inst✝ : Algebra R C
⊢ ⇑(NonUnitalAlgHom.toAlgHom 0) = fst
state_after: case h
S : Type u_1
R : Type u_2
A : Type u_3
inst✝¹² : CommSemiring S
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : NonUnitalSemiring A
inst✝⁹ : Module R A
inst✝⁸ : SMulCommClass R A A
inst✝⁷ : IsScalarTower R A A
B : Type u_4
inst✝⁶ : Semiring B
inst✝⁵ : Algebra S B
inst✝⁴ : Algebra S R
inst✝³ : DistribMulAction S A
inst✝² : IsScalarTower S R A
C : Type u_5
inst✝¹ : Semiring C
inst✝ : Algebra R C
x✝ : Unitization R A
⊢ (NonUnitalAlgHom.toAlgHom 0) x✝ = x✝.fst

tactic: simp
state_before: case h
S : Type u_1
R : Type u_2
A : Type u_3
inst✝¹² : CommSemiring S
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : NonUnitalSemiring A
inst✝⁹ : Module R A
inst✝⁸ : SMulCommClass R A A
inst✝⁷ : IsScalarTower R A A
B : Type u_4
inst✝⁶ : Semiring B
inst✝⁵ : Algebra S B
inst✝⁴ : Algebra S R
inst✝³ : DistribMulAction S A
inst✝² : IsScalarTower S R A
C : Type u_5
inst✝¹ : Semiring C
inst✝ : Algebra R C
x✝ : Unitization R A
⊢ (NonUnitalAlgHom.toAlgHom 0) x✝ = x✝.fst
state_after: no goals
Theorem: Equiv.forall_congr'
File: Mathlib/Logic/Equiv/Defs.lean

tactic: simp [h]
state_before: α : Sort u
β : Sort v
γ : Sort w
p : α → Prop
q : β → Prop
e : α ≃ β
h : ∀ (b : β), p (e.symm b) ↔ q b
⊢ (∀ (b : β), p (e.symm b)) ↔ ∀ (b : β), q b
state_after: no goals
Theorem: MeasureTheory.integral_singleton
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [Measure.restrict_singleton, integral_smul_measure, integral_dirac, smul_eq_mul,
  mul_comm]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : SMulCommClass ℝ 𝕜 E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : CompleteSpace F
G : Type u_5
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace ℝ G
f✝ g : α → E
m : MeasurableSpace α
μ✝ : Measure α
X : Type u_6
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
ν : Measure α
inst✝ : MeasurableSingletonClass α
μ : Measure α
f : α → E
a : α
⊢ ∫ (a : α) in {a}, f a ∂μ = (μ {a}).toReal • f a
state_after: no goals
Theorem: CategoryTheory.isCoseparator_op_iff
File: Mathlib/CategoryTheory/Generator.lean

tactic: rw [IsSeparator, IsCoseparator, ← isCoseparating_op_iff, Set.singleton_op]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C
⊢ IsCoseparator { unop := G } ↔ IsSeparator G
state_after: no goals
Theorem: Nat.choose_le_succ
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: cases c <;> simp [Nat.choose_succ_succ]
state_before: a c : ℕ
⊢ a.choose c ≤ a.succ.choose c
state_after: no goals
Theorem: MvPolynomial.mem_restrictDegree_iff_sup
File: Mathlib/RingTheory/MvPolynomial/Basic.lean

tactic: simp only [mem_restrictDegree, degrees_def, Multiset.count_finset_sup, Finsupp.count_toMultiset,
  Finset.sup_le_iff]
state_before: σ : Type u
R : Type v
inst✝¹ : CommSemiring R
p✝ m : ℕ
inst✝ : DecidableEq σ
p : MvPolynomial σ R
n : ℕ
⊢ p ∈ restrictDegree σ R n ↔ ∀ (i : σ), Multiset.count i p.degrees ≤ n
state_after: σ : Type u
R : Type v
inst✝¹ : CommSemiring R
p✝ m : ℕ
inst✝ : DecidableEq σ
p : MvPolynomial σ R
n : ℕ
⊢ (∀ s ∈ p.support, ∀ (i : σ), s i ≤ n) ↔ ∀ (i : σ), ∀ b ∈ p.support, b i ≤ n

tactic: exact ⟨fun h n s hs => h s hs n, fun h s hs n => h n s hs⟩
state_before: σ : Type u
R : Type v
inst✝¹ : CommSemiring R
p✝ m : ℕ
inst✝ : DecidableEq σ
p : MvPolynomial σ R
n : ℕ
⊢ (∀ s ∈ p.support, ∀ (i : σ), s i ≤ n) ↔ ∀ (i : σ), ∀ b ∈ p.support, b i ≤ n
state_after: no goals
Theorem: UniformContinuous.inv
File: Mathlib/Topology/Algebra/UniformGroup.lean

tactic: have : UniformContinuous fun x => 1 / f x := uniformContinuous_const.div hf
state_before: α : Type u_1
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f : β → α
hf : UniformContinuous f
⊢ UniformContinuous fun x => (f x)⁻¹
state_after: α : Type u_1
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f : β → α
hf : UniformContinuous f
this : UniformContinuous fun x => 1 / f x
⊢ UniformContinuous fun x => (f x)⁻¹

tactic: simp_all
state_before: α : Type u_1
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f : β → α
hf : UniformContinuous f
this : UniformContinuous fun x => 1 / f x
⊢ UniformContinuous fun x => (f x)⁻¹
state_after: no goals
Theorem: indicator_ae_eq_restrict
File: Mathlib/MeasureTheory/Measure/Restrict.lean

tactic: classical exact piecewise_ae_eq_restrict hs
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
inst✝¹ : MeasurableSpace α
μ : Measure α
s t : Set α
f : α → β
inst✝ : Zero β
hs : MeasurableSet s
⊢ s.indicator f =ᶠ[ae (μ.restrict s)] f
state_after: no goals

tactic: exact piecewise_ae_eq_restrict hs
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
inst✝¹ : MeasurableSpace α
μ : Measure α
s t : Set α
f : α → β
inst✝ : Zero β
hs : MeasurableSet s
⊢ s.indicator f =ᶠ[ae (μ.restrict s)] f
state_after: no goals
Theorem: ENNReal.ofReal_lt_one
File: Mathlib/Data/ENNReal/Real.lean

tactic: exact mod_cast ofReal_lt_natCast one_ne_zero
state_before: a b c d : ℝ≥0∞
r p✝ q : ℝ≥0
p : ℝ
⊢ ENNReal.ofReal p < 1 ↔ p < 1
state_after: no goals
Theorem: Finset.exists_le_of_prod_le'
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

tactic: contrapose! Hle with Hlt
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✝ : LinearOrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
hs : s.Nonempty
Hle : ∏ i ∈ s, f i ≤ ∏ i ∈ s, g i
⊢ ∃ i ∈ s, f i ≤ g i
state_after: ι : 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✝ : LinearOrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
hs : s.Nonempty
Hlt : ∀ i ∈ s, g i < f i
⊢ ∏ i ∈ s, g i < ∏ i ∈ s, f i

tactic: exact prod_lt_prod_of_nonempty' hs Hlt
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✝ : LinearOrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
hs : s.Nonempty
Hlt : ∀ i ∈ s, g i < f i
⊢ ∏ i ∈ s, g i < ∏ i ∈ s, f i
state_after: no goals
Theorem: Submonoid.list_prod_mem
File: Mathlib/Algebra/Group/Submonoid/Membership.lean

tactic: lift l to List s using hl
state_before: M : Type u_1
A : Type u_2
B : Type u_3
inst✝² : Monoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
S : B
s : Submonoid M
l : List M
hl : ∀ x ∈ l, x ∈ s
⊢ l.prod ∈ s
state_after: case intro
M : Type u_1
A : Type u_2
B : Type u_3
inst✝² : Monoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
S : B
s : Submonoid M
l : List ↥s
⊢ (List.map Subtype.val l).prod ∈ s

tactic: rw [← coe_list_prod]
state_before: case intro
M : Type u_1
A : Type u_2
B : Type u_3
inst✝² : Monoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
S : B
s : Submonoid M
l : List ↥s
⊢ (List.map Subtype.val l).prod ∈ s
state_after: case intro
M : Type u_1
A : Type u_2
B : Type u_3
inst✝² : Monoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
S : B
s : Submonoid M
l : List ↥s
⊢ ↑l.prod ∈ s

tactic: exact l.prod.coe_prop
state_before: case intro
M : Type u_1
A : Type u_2
B : Type u_3
inst✝² : Monoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
S : B
s : Submonoid M
l : List ↥s
⊢ ↑l.prod ∈ s
state_after: no goals
Theorem: Fin.castPred_succAbove
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [castPred_eq_iff_eq_castSucc, succAbove_of_castSucc_lt _ _ h]
state_before: n m : ℕ
p : Fin (n + 1)
i j x : Fin n
y : Fin (n + 1)
h : x.castSucc < y
h' : optParam (y.succAbove x ≠ last n) ⋯
⊢ (y.succAbove x).castPred h' = x
state_after: no goals
Theorem: AlgebraicTopology.DoldKan.PInftyToNormalizedMooreComplex_naturality
File: Mathlib/AlgebraicTopology/DoldKan/Normalized.lean

tactic: aesop_cat
state_before: A : Type u_1
inst✝¹ : Category.{u_2, u_1} A
inst✝ : Abelian A
X✝ X Y : SimplicialObject A
f : X ⟶ Y
⊢ AlternatingFaceMapComplex.map f ≫ PInftyToNormalizedMooreComplex Y =
    PInftyToNormalizedMooreComplex X ≫ NormalizedMooreComplex.map f
state_after: no goals
Theorem: Stream'.WSeq.liftRel_destruct
File: Mathlib/Data/Seq/WSeq.lean

tactic: refine Computation.LiftRel.imp ?_ _ _ (h2 h1)
state_before: α : Type u
β : Type v
γ : Type w
R✝ : α → β → Prop
s : WSeq α
t : WSeq β
R : WSeq α → WSeq β → Prop
h1 : R s t
h2 : ∀ {s : WSeq α} {t : WSeq β}, R s t → Computation.LiftRel (LiftRelO R✝ R) s.destruct t.destruct
⊢ Computation.LiftRel (LiftRelO R✝ (LiftRel R✝)) s.destruct t.destruct
state_after: α : Type u
β : Type v
γ : Type w
R✝ : α → β → Prop
s : WSeq α
t : WSeq β
R : WSeq α → WSeq β → Prop
h1 : R s t
h2 : ∀ {s : WSeq α} {t : WSeq β}, R s t → Computation.LiftRel (LiftRelO R✝ R) s.destruct t.destruct
⊢ ∀ {a : Option (α × WSeq α)} {b : Option (β × WSeq β)}, LiftRelO R✝ R a b → LiftRelO R✝ (LiftRel R✝) a b

tactic: apply LiftRelO.imp_right
state_before: α : Type u
β : Type v
γ : Type w
R✝ : α → β → Prop
s : WSeq α
t : WSeq β
R : WSeq α → WSeq β → Prop
h1 : R s t
h2 : ∀ {s : WSeq α} {t : WSeq β}, R s t → Computation.LiftRel (LiftRelO R✝ R) s.destruct t.destruct
⊢ ∀ {a : Option (α × WSeq α)} {b : Option (β × WSeq β)}, LiftRelO R✝ R a b → LiftRelO R✝ (LiftRel R✝) a b
state_after: case H
α : Type u
β : Type v
γ : Type w
R✝ : α → β → Prop
s : WSeq α
t : WSeq β
R : WSeq α → WSeq β → Prop
h1 : R s t
h2 : ∀ {s : WSeq α} {t : WSeq β}, R s t → Computation.LiftRel (LiftRelO R✝ R) s.destruct t.destruct
⊢ ∀ (s : WSeq α) (t : WSeq β), R s t → LiftRel R✝ s t

tactic: exact fun s' t' h' => ⟨R, h', @h2⟩
state_before: case H
α : Type u
β : Type v
γ : Type w
R✝ : α → β → Prop
s : WSeq α
t : WSeq β
R : WSeq α → WSeq β → Prop
h1 : R s t
h2 : ∀ {s : WSeq α} {t : WSeq β}, R s t → Computation.LiftRel (LiftRelO R✝ R) s.destruct t.destruct
⊢ ∀ (s : WSeq α) (t : WSeq β), R s t → LiftRel R✝ s t
state_after: no goals
Theorem: div_self_mul_self'
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: simp [mul_inv_rev]
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : GroupWithZero G₀
a✝ b c a : G₀
⊢ a / (a * a) = a⁻¹⁻¹ * a⁻¹ * a⁻¹
state_after: no goals
Theorem: circleIntegral.integral_congr
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

tactic: simp only [h (circleMap_mem_sphere _ hR _)]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f g : ℂ → E
c : ℂ
R : ℝ
hR : 0 ≤ R
h : EqOn f g (sphere c R)
θ : ℝ
x✝ : θ ∈ [[0, 2 * π]]
⊢ deriv (circleMap c R) θ • (fun z => f z) (circleMap c R θ) =
    deriv (circleMap c R) θ • (fun z => g z) (circleMap c R θ)
state_after: no goals
Theorem: Nat.sq_mul_squarefree
File: Mathlib/Data/Nat/Squarefree.lean

tactic: cases' n with n
state_before: s : Finset ℕ
m n✝ p n : ℕ
⊢ ∃ a b, b ^ 2 * a = n ∧ Squarefree a
state_after: case zero
s : Finset ℕ
m n p : ℕ
⊢ ∃ a b, b ^ 2 * a = 0 ∧ Squarefree a

case succ
s : Finset ℕ
m n✝ p n : ℕ
⊢ ∃ a b, b ^ 2 * a = n + 1 ∧ Squarefree a

tactic: exact ⟨1, 0, by simp, squarefree_one⟩
state_before: case zero
s : Finset ℕ
m n p : ℕ
⊢ ∃ a b, b ^ 2 * a = 0 ∧ Squarefree a
state_after: no goals

tactic: simp
state_before: s : Finset ℕ
m n p : ℕ
⊢ 0 ^ 2 * 1 = 0
state_after: no goals

tactic: obtain ⟨a, b, -, -, h₁, h₂⟩ := sq_mul_squarefree_of_pos (succ_pos n)
state_before: case succ
s : Finset ℕ
m n✝ p n : ℕ
⊢ ∃ a b, b ^ 2 * a = n + 1 ∧ Squarefree a
state_after: case succ.intro.intro.intro.intro.intro
s : Finset ℕ
m n✝ p n a b : ℕ
h₁ : b ^ 2 * a = n.succ
h₂ : Squarefree a
⊢ ∃ a b, b ^ 2 * a = n + 1 ∧ Squarefree a

tactic: exact ⟨a, b, h₁, h₂⟩
state_before: case succ.intro.intro.intro.intro.intro
s : Finset ℕ
m n✝ p n a b : ℕ
h₁ : b ^ 2 * a = n.succ
h₂ : Squarefree a
⊢ ∃ a b, b ^ 2 * a = n + 1 ∧ Squarefree a
state_after: no goals
Theorem: ZFSet.IsTransitive.sUnion'
File: Mathlib/SetTheory/ZFC/Ordinal.lean

tactic: rcases mem_sUnion.1 hy with ⟨w, hw, hw'⟩
state_before: x y✝ z✝ : ZFSet
H : ∀ y ∈ x, y.IsTransitive
y : ZFSet
hy : y ∈ ⋃₀ x
z : ZFSet
hz : z ∈ y
⊢ z ∈ ⋃₀ x
state_after: case intro.intro
x y✝ z✝ : ZFSet
H : ∀ y ∈ x, y.IsTransitive
y : ZFSet
hy : y ∈ ⋃₀ x
z : ZFSet
hz : z ∈ y
w : ZFSet
hw : w ∈ x
hw' : y ∈ w
⊢ z ∈ ⋃₀ x

tactic: exact mem_sUnion_of_mem ((H w hw).mem_trans hz hw') hw
state_before: case intro.intro
x y✝ z✝ : ZFSet
H : ∀ y ∈ x, y.IsTransitive
y : ZFSet
hy : y ∈ ⋃₀ x
z : ZFSet
hz : z ∈ y
w : ZFSet
hw : w ∈ x
hw' : y ∈ w
⊢ z ∈ ⋃₀ x
state_after: no goals
Theorem: Pell.IsFundamental.mul_inv_y_nonneg
File: Mathlib/NumberTheory/Pell.lean

tactic: simpa only [y_inv, mul_neg, y_mul, le_neg_add_iff_add_le, add_zero] using
  h.x_mul_y_le_y_mul_x hax hay
state_before: d : ℤ
a₁ : Solution₁ d
h : IsFundamental a₁
a : Solution₁ d
hax : 1 < a.x
hay : 0 < a.y
⊢ 0 ≤ (a * a₁⁻¹).y
state_after: no goals