1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.Equalizer.Presieve.Arrows.w
File: Mathlib/CategoryTheory/Sites/EqualizerSheafCondition.lean

tactic: ext x ij
state_before: C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
⊢ forkMap P X π ≫ firstMap P X π = forkMap P X π ≫ secondMap P X π
state_after: case h.h
C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
x : P.obj { unop := B }
ij : I × I
⊢ Pi.π (fun ij => P.obj { unop := Limits.pullback (π ij.1) (π ij.2) }) ij ((forkMap P X π ≫ firstMap P X π) x) =
    Pi.π (fun ij => P.obj { unop := Limits.pullback (π ij.1) (π ij.2) }) ij ((forkMap P X π ≫ secondMap P X π) x)

tactic: simp only [firstMap, secondMap, forkMap, types_comp_apply, Types.pi_lift_π_apply,
  ← FunctorToTypes.map_comp_apply, ← op_comp, pullback.condition]
state_before: case h.h
C : Type u
inst✝² : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type (max v u)
X✝¹ : C
R✝ : Presieve X✝¹
S✝ : Sieve X✝¹
inst✝¹ : R✝.hasPullbacks
P : Cᵒᵖ ⥤ Type w
X✝ : C
R : Presieve X✝
S : Sieve X✝
B : C
I : Type
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (Presieve.ofArrows X π).hasPullbacks
x : P.obj { unop := B }
ij : I × I
⊢ Pi.π (fun ij => P.obj { unop := Limits.pullback (π ij.1) (π ij.2) }) ij ((forkMap P X π ≫ firstMap P X π) x) =
    Pi.π (fun ij => P.obj { unop := Limits.pullback (π ij.1) (π ij.2) }) ij ((forkMap P X π ≫ secondMap P X π) x)
state_after: no goals
Theorem: Filter.Tendsto.atBot_mul
File: Mathlib/Topology/Algebra/Order/Field.lean

tactic: have := (tendsto_neg_atBot_atTop.comp hf).atTop_mul hC hg
state_before: 𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
C : 𝕜
hC : 0 < C
hf : Tendsto f l atBot
hg : Tendsto g l (𝓝 C)
⊢ Tendsto (fun x => f x * g x) l atBot
state_after: 𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
C : 𝕜
hC : 0 < C
hf : Tendsto f l atBot
hg : Tendsto g l (𝓝 C)
this : Tendsto (fun x => (Neg.neg ∘ f) x * g x) l atTop
⊢ Tendsto (fun x => f x * g x) l atBot
Theorem: Finset.powersetCard_one
File: Mathlib/Data/Finset/Powerset.lean

tactic: simp [Multiset.powersetCard_one]
state_before: α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.18311
s✝ t s : Finset α
⊢ Multiset.map val (powersetCard 1 s).val = Multiset.map val (map { toFun := singleton, inj' := ⋯ } s).val
state_after: no goals
Theorem: Fin.le_insertNth_iff
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: simp [Pi.le_def, forall_iff_succAbove i]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
inst✝ : (i : Fin (n + 1)) → Preorder (α i)
i : Fin (n + 1)
x : α i
p : (j : Fin n) → α (i.succAbove j)
q : (j : Fin (n + 1)) → α j
⊢ q ≤ i.insertNth x p ↔ q i ≤ x ∧ (fun j => q (i.succAbove j)) ≤ p
state_after: no goals
Theorem: sdiff_inf_distrib
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [sup_le_iff, sdiff_le_comm, le_inf_iff]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedCoheytingAlgebra α
a✝ b✝ c✝ d✝ a b c d : α
⊢ a \ (b ⊓ c) ≤ d ↔ a \ b ⊔ a \ c ≤ d
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedCoheytingAlgebra α
a✝ b✝ c✝ d✝ a b c d : α
⊢ a \ d ≤ b ∧ a \ d ≤ c ↔ a \ b ≤ d ∧ a \ c ≤ d

tactic: simp_rw [sdiff_le_comm]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedCoheytingAlgebra α
a✝ b✝ c✝ d✝ a b c d : α
⊢ a \ d ≤ b ∧ a \ d ≤ c ↔ a \ b ≤ d ∧ a \ c ≤ d
state_after: no goals
Theorem: LaurentPolynomial.leftInverse_trunc_toLaurent
File: Mathlib/Algebra/Polynomial/Laurent.lean

tactic: refine fun f => f.induction_on' ?_ ?_
state_before: R : Type u_1
inst✝ : Semiring R
⊢ LeftInverse ⇑trunc ⇑toLaurent
state_after: case refine_1
R : Type u_1
inst✝ : Semiring R
f : R[X]
⊢ ∀ (p q : R[X]), trunc (toLaurent p) = p → trunc (toLaurent q) = q → trunc (toLaurent (p + q)) = p + q

case refine_2
R : Type u_1
inst✝ : Semiring R
f : R[X]
⊢ ∀ (n : ℕ) (a : R), trunc (toLaurent ((monomial n) a)) = (monomial n) a

tactic: intro f g hf hg
state_before: case refine_1
R : Type u_1
inst✝ : Semiring R
f : R[X]
⊢ ∀ (p q : R[X]), trunc (toLaurent p) = p → trunc (toLaurent q) = q → trunc (toLaurent (p + q)) = p + q
state_after: case refine_1
R : Type u_1
inst✝ : Semiring R
f✝ f g : R[X]
hf : trunc (toLaurent f) = f
hg : trunc (toLaurent g) = g
⊢ trunc (toLaurent (f + g)) = f + g

tactic: simp only [hf, hg, _root_.map_add]
state_before: case refine_1
R : Type u_1
inst✝ : Semiring R
f✝ f g : R[X]
hf : trunc (toLaurent f) = f
hg : trunc (toLaurent g) = g
⊢ trunc (toLaurent (f + g)) = f + g
state_after: no goals

tactic: intro n r
state_before: case refine_2
R : Type u_1
inst✝ : Semiring R
f : R[X]
⊢ ∀ (n : ℕ) (a : R), trunc (toLaurent ((monomial n) a)) = (monomial n) a
state_after: case refine_2
R : Type u_1
inst✝ : Semiring R
f : R[X]
n : ℕ
r : R
⊢ trunc (toLaurent ((monomial n) r)) = (monomial n) r

tactic: simp only [Polynomial.toLaurent_C_mul_T, trunc_C_mul_T, Int.natCast_nonneg, Int.toNat_natCast,
  if_true]
state_before: case refine_2
R : Type u_1
inst✝ : Semiring R
f : R[X]
n : ℕ
r : R
⊢ trunc (toLaurent ((monomial n) r)) = (monomial n) r
state_after: no goals
Theorem: Nat.maxPowDiv.zero
File: Mathlib/Data/Nat/MaxPowDiv.lean

tactic: dsimp [maxPowDiv]
state_before: p : ℕ
⊢ p.maxPowDiv 0 = 0
state_after: p : ℕ
⊢ go 0 p 0 = 0

tactic: rw [maxPowDiv.go]
state_before: p : ℕ
⊢ go 0 p 0 = 0
state_after: p : ℕ
⊢ (if 1 < p ∧ 0 < 0 ∧ 0 % p = 0 then go (0 + 1) p (0 / p) else 0) = 0

tactic: simp
state_before: p : ℕ
⊢ (if 1 < p ∧ 0 < 0 ∧ 0 % p = 0 then go (0 + 1) p (0 / p) else 0) = 0
state_after: no goals
Theorem: NNReal.orderIsoRpow_symm_eq
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: simp only [orderIsoRpow, one_div_one_div]
state_before: w x y✝ z y : ℝ
hy : 0 < y
⊢ (orderIsoRpow y hy).symm = orderIsoRpow (1 / y) ⋯
state_after: w x y✝ z y : ℝ
hy : 0 < y
⊢ (StrictMono.orderIsoOfRightInverse (fun x => x ^ y) ⋯ (fun x => x ^ (1 / y)) ⋯).symm =
    StrictMono.orderIsoOfRightInverse (fun x => x ^ (1 / y)) ⋯ (fun x => x ^ y) ⋯

tactic: rfl
state_before: w x y✝ z y : ℝ
hy : 0 < y
⊢ (StrictMono.orderIsoOfRightInverse (fun x => x ^ y) ⋯ (fun x => x ^ (1 / y)) ⋯).symm =
    StrictMono.orderIsoOfRightInverse (fun x => x ^ (1 / y)) ⋯ (fun x => x ^ y) ⋯
state_after: no goals
Theorem: CategoryTheory.Limits.cokernelComparison_map_desc
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

tactic: simp only [← G.map_comp, w, Functor.map_zero]
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
inst✝³ : HasZeroMorphisms D
G : C ⥤ D
inst✝² : G.PreservesZeroMorphisms
inst✝¹ : HasCokernel f
inst✝ : HasCokernel (G.map f)
Z : C
h : Y ⟶ Z
w : f ≫ h = 0
⊢ G.map f ≫ G.map h = 0
state_after: no goals

tactic: ext
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
inst✝³ : HasZeroMorphisms D
G : C ⥤ D
inst✝² : G.PreservesZeroMorphisms
inst✝¹ : HasCokernel f
inst✝ : HasCokernel (G.map f)
Z : C
h : Y ⟶ Z
w : f ≫ h = 0
⊢ cokernelComparison f G ≫ G.map (cokernel.desc f h w) = cokernel.desc (G.map f) (G.map h) ⋯
state_after: case h
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
inst✝³ : HasZeroMorphisms D
G : C ⥤ D
inst✝² : G.PreservesZeroMorphisms
inst✝¹ : HasCokernel f
inst✝ : HasCokernel (G.map f)
Z : C
h : Y ⟶ Z
w : f ≫ h = 0
⊢ coequalizer.π (G.map f) 0 ≫ cokernelComparison f G ≫ G.map (cokernel.desc f h w) =
    coequalizer.π (G.map f) 0 ≫ cokernel.desc (G.map f) (G.map h) ⋯

tactic: simp [← G.map_comp]
state_before: case h
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
inst✝³ : HasZeroMorphisms D
G : C ⥤ D
inst✝² : G.PreservesZeroMorphisms
inst✝¹ : HasCokernel f
inst✝ : HasCokernel (G.map f)
Z : C
h : Y ⟶ Z
w : f ≫ h = 0
⊢ coequalizer.π (G.map f) 0 ≫ cokernelComparison f G ≫ G.map (cokernel.desc f h w) =
    coequalizer.π (G.map f) 0 ≫ cokernel.desc (G.map f) (G.map h) ⋯
state_after: no goals
Theorem: MeasureTheory.ae_restrict_of_ae_eq_of_ae_restrict
File: Mathlib/MeasureTheory/Measure/Restrict.lean

tactic: simp [Measure.restrict_congr_set hst]
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 α
s t : α → Prop
hst : s =ᶠ[ae μ] t
p : α → Prop
⊢ (∀ᵐ (x : α) ∂μ.restrict s, p x) → ∀ᵐ (x : α) ∂μ.restrict t, p x
state_after: no goals
Theorem: MeasureTheory.summable_measure_toReal
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

tactic: apply ENNReal.summable_toReal
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
hμ : IsFiniteMeasure μ
f : ℕ → Set α
hf₁ : ∀ (i : ℕ), MeasurableSet (f i)
hf₂ : Pairwise (Disjoint on f)
⊢ Summable fun x => (μ (f x)).toReal
state_after: case hsum
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
hμ : IsFiniteMeasure μ
f : ℕ → Set α
hf₁ : ∀ (i : ℕ), MeasurableSet (f i)
hf₂ : Pairwise (Disjoint on f)
⊢ ∑' (x : ℕ), μ (f x) ≠ ⊤

tactic: rw [← MeasureTheory.measure_iUnion hf₂ hf₁]
state_before: case hsum
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
hμ : IsFiniteMeasure μ
f : ℕ → Set α
hf₁ : ∀ (i : ℕ), MeasurableSet (f i)
hf₂ : Pairwise (Disjoint on f)
⊢ ∑' (x : ℕ), μ (f x) ≠ ⊤
state_after: case hsum
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
hμ : IsFiniteMeasure μ
f : ℕ → Set α
hf₁ : ∀ (i : ℕ), MeasurableSet (f i)
hf₂ : Pairwise (Disjoint on f)
⊢ μ (⋃ i, f i) ≠ ⊤

tactic: exact ne_of_lt (measure_lt_top _ _)
state_before: case hsum
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
hμ : IsFiniteMeasure μ
f : ℕ → Set α
hf₁ : ∀ (i : ℕ), MeasurableSet (f i)
hf₂ : Pairwise (Disjoint on f)
⊢ μ (⋃ i, f i) ≠ ⊤
state_after: no goals
Theorem: RatFunc.eval_C
File: Mathlib/FieldTheory/RatFunc/AsPolynomial.lean

tactic: simp [eval]
state_before: K : Type u
inst✝¹ : Field K
L : Type u
inst✝ : Field L
f : K →+* L
a : L
c : K
⊢ eval f a (C c) = f c
state_after: no goals
Theorem: Set.toFinset_Ioc
File: Mathlib/Order/Interval/Finset/Defs.lean

tactic: ext
state_before: α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
y : α✝
α : Type u_3
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a b : α
inst✝ : Fintype ↑(Ioc a b)
⊢ (Ioc a b).toFinset = Finset.Ioc a b
state_after: case a
α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
y : α✝
α : Type u_3
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a b : α
inst✝ : Fintype ↑(Ioc a b)
a✝ : α
⊢ a✝ ∈ (Ioc a b).toFinset ↔ a✝ ∈ Finset.Ioc a b

tactic: simp
state_before: case a
α✝ : Type u_1
β : Type u_2
inst✝⁴ : Preorder α✝
p : α✝ → Prop
inst✝³ : DecidablePred p
y : α✝
α : Type u_3
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a b : α
inst✝ : Fintype ↑(Ioc a b)
a✝ : α
⊢ a✝ ∈ (Ioc a b).toFinset ↔ a✝ ∈ Finset.Ioc a b
state_after: no goals
Theorem: Primrec.subtype_val
File: Mathlib/Computability/Primrec.lean

tactic: letI := Primcodable.subtype hp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable σ
p : α → Prop
inst✝ : DecidablePred p
hp : PrimrecPred p
⊢ Primrec Subtype.val
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable σ
p : α → Prop
inst✝ : DecidablePred p
hp : PrimrecPred p
this : Primcodable (Subtype p) := Primcodable.subtype hp
⊢ Primrec Subtype.val

tactic: refine (@Primcodable.prim (Subtype p)).of_eq fun n => ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable σ
p : α → Prop
inst✝ : DecidablePred p
hp : PrimrecPred p
this : Primcodable (Subtype p) := Primcodable.subtype hp
⊢ Primrec Subtype.val
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable σ
p : α → Prop
inst✝ : DecidablePred p
hp : PrimrecPred p
this : Primcodable (Subtype p) := Primcodable.subtype hp
n : ℕ
⊢ encode (decode n) = encode (Option.map Subtype.val (decode n))

tactic: rcases @decode (Subtype p) _ n with (_ | ⟨a, h⟩) <;> rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable σ
p : α → Prop
inst✝ : DecidablePred p
hp : PrimrecPred p
this : Primcodable (Subtype p) := Primcodable.subtype hp
n : ℕ
⊢ encode (decode n) = encode (Option.map Subtype.val (decode n))
state_after: no goals
Theorem: Nat.div_pos_iff
File: Mathlib/Data/Nat/Defs.lean

tactic: rw [Nat.pos_iff_ne_zero, Nat.div_ne_zero_iff hb]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hb : b ≠ 0
⊢ 0 < a / b ↔ b ≤ a
state_after: no goals
Theorem: aemeasurable_inv_iff
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

tactic: simpa only [inv_inv] using h.inv
state_before: α✝ : Type u_1
G✝ : Type u_2
α : Type u_3
inst✝⁵ : Inv G✝
inst✝⁴ : MeasurableSpace G✝
inst✝³ : MeasurableInv G✝
m : MeasurableSpace α
f✝ : α → G✝
μ : Measure α
G : Type u_4
inst✝² : Group G
inst✝¹ : MeasurableSpace G
inst✝ : MeasurableInv G
f : α → G
h : AEMeasurable (fun x => (f x)⁻¹) μ
⊢ AEMeasurable f μ
state_after: no goals
Theorem: Ctop.Realizer.ofEquiv_F
File: Mathlib/Data/Analysis/Topology.lean

tactic: delta ofEquiv
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
τ : Type u_4
inst✝ : TopologicalSpace α
F : Realizer α
E : F.σ ≃ τ
s : τ
⊢ (F.ofEquiv E).F.f s = F.F.f (E.symm s)
state_after: α : Type u_1
β : Type u_2
σ : Type u_3
τ : Type u_4
inst✝ : TopologicalSpace α
F : Realizer α
E : F.σ ≃ τ
s : τ
⊢ { σ := τ, F := Ctop.ofEquiv E F.F, eq := ⋯ }.F.f s = F.F.f (E.symm s)

tactic: simp
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
τ : Type u_4
inst✝ : TopologicalSpace α
F : Realizer α
E : F.σ ≃ τ
s : τ
⊢ { σ := τ, F := Ctop.ofEquiv E F.F, eq := ⋯ }.F.f s = F.F.f (E.symm s)
state_after: no goals
Theorem: Function.Antiperiodic.nsmul_sub_eq
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [Int.reduceNeg, natCast_zsmul] using h.zsmul_sub_eq n
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddCommGroup α
inst✝ : AddGroup β
h : Antiperiodic f c
n : ℕ
⊢ f (n • c - x) = (-1) ^ n • f (-x)
state_after: no goals
Theorem: NFA.evalFrom_append_singleton
File: Mathlib/Computability/NFA.lean

tactic: simp only [evalFrom, List.foldl_append, List.foldl_cons, List.foldl_nil]
state_before: α : Type u
σ σ' : Type v
M : NFA α σ
S : Set σ
x : List α
a : α
⊢ M.evalFrom S (x ++ [a]) = M.stepSet (M.evalFrom S x) a
state_after: no goals
Theorem: EuclideanDomain.div_self
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

tactic: simpa only [one_mul] using mul_div_cancel_right₀ 1 a0
state_before: R : Type u
inst✝ : EuclideanDomain R
a : R
a0 : a ≠ 0
⊢ a / a = 1
state_after: no goals
Theorem: Vector.get_cons_zero
File: Mathlib/Data/Vector/Basic.lean

tactic: simp [get_zero]
state_before: n : ℕ
α : Type u_1
a : α
v : Vector α n
⊢ (a ::ᵥ v).get 0 = a
state_after: no goals
Theorem: symmDiff_of_ge
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff, sdiff_eq_bot_iff.2 h, sup_bot_eq]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a✝ b✝ c d a b : α
h : b ≤ a
⊢ a ∆ b = a \ b
state_after: no goals
Theorem: Set.isEmpty_coe_sort
File: Mathlib/Data/Set/Basic.lean

tactic: simpa using nonempty_iff_ne_empty
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
⊢ ¬IsEmpty ↑s ↔ ¬s = ∅
state_after: no goals
Theorem: Equiv.Perm.Disjoint.mul_eq_one_iff
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: simp_rw [ext_iff, one_apply, hστ.mul_apply_eq_iff, forall_and]
state_before: α : Type u_1
f g h σ τ : Perm α
hστ : σ.Disjoint τ
⊢ σ * τ = 1 ↔ σ = 1 ∧ τ = 1
state_after: no goals
Theorem: Set.image2_singleton
File: Mathlib/Data/Set/NAry.lean

tactic: simp
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ image2 f {a} {b} = {f a b}
state_after: no goals
Theorem: clusterPt_iff_lift'_closure
File: Mathlib/Topology/Basic.lean

tactic: simp_rw [clusterPt_iff_forall_mem_closure,
  (hasBasis_pure _).le_basis_iff F.basis_sets.lift'_closure, id, singleton_subset_iff, true_and,
  exists_const]
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
F : Filter X
⊢ ClusterPt x F ↔ pure x ≤ F.lift' closure
state_after: no goals
Theorem: Ring.inverse_mul_cancel_right
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: rw [mul_assoc, inverse_mul_cancel x h, mul_one]
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✝ : MonoidWithZero M₀
x y : M₀
h : IsUnit x
⊢ y * inverse x * x = y
state_after: no goals
Theorem: sign_zero
File: Mathlib/Data/Sign.lean

tactic: simp [sign_apply]
state_before: α : Type u_1
inst✝² : Zero α
inst✝¹ : Preorder α
inst✝ : DecidableRel fun x x_1 => x < x_1
a : α
⊢ sign 0 = 0
state_after: no goals
Theorem: CategoryTheory.Limits.preserves_cokernel_iso_comp_cokernel_map
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Kernels.lean

tactic: rw [← G.map_comp, hpq, G.map_comp]
state_before: C : Type u₁
inst✝¹⁰ : Category.{v₁, u₁} C
inst✝⁹ : HasZeroMorphisms C
D : Type u₂
inst✝⁸ : Category.{v₂, u₂} D
inst✝⁷ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁶ : G.PreservesZeroMorphisms
X Y Z : C
f : X ⟶ Y
h : Y ⟶ Z
w : f ≫ h = 0
inst✝⁵ : HasCokernel f
inst✝⁴ : HasCokernel (G.map f)
inst✝³ : PreservesColimit (parallelPair f 0) G
X' Y' : C
g : X' ⟶ Y'
inst✝² : HasCokernel g
inst✝¹ : HasCokernel (G.map g)
inst✝ : PreservesColimit (parallelPair g 0) G
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ G.map f ≫ G.map q = G.map p ≫ G.map g
state_after: no goals

tactic: rw [← Iso.comp_inv_eq, Category.assoc, ← Iso.eq_inv_comp, PreservesCokernel.iso_inv,
  cokernel_map_comp_cokernelComparison, PreservesCokernel.iso_inv]
state_before: C : Type u₁
inst✝¹⁰ : Category.{v₁, u₁} C
inst✝⁹ : HasZeroMorphisms C
D : Type u₂
inst✝⁸ : Category.{v₂, u₂} D
inst✝⁷ : HasZeroMorphisms D
G : C ⥤ D
inst✝⁶ : G.PreservesZeroMorphisms
X Y Z : C
f : X ⟶ Y
h : Y ⟶ Z
w : f ≫ h = 0
inst✝⁵ : HasCokernel f
inst✝⁴ : HasCokernel (G.map f)
inst✝³ : PreservesColimit (parallelPair f 0) G
X' Y' : C
g : X' ⟶ Y'
inst✝² : HasCokernel g
inst✝¹ : HasCokernel (G.map g)
inst✝ : PreservesColimit (parallelPair g 0) G
p : X ⟶ X'
q : Y ⟶ Y'
hpq : f ≫ q = p ≫ g
⊢ (PreservesCokernel.iso G f).hom ≫ cokernel.map (G.map f) (G.map g) (G.map p) (G.map q) ⋯ =
    G.map (cokernel.map f g p q hpq) ≫ (PreservesCokernel.iso G g).hom
state_after: no goals
Theorem: hasDerivAt_iff_tendsto_slope_zero
File: Mathlib/Analysis/Calculus/Deriv/Slope.lean

tactic: have : 𝓝[≠] x = Filter.map (fun t ↦ x + t) (𝓝[≠] 0) := by
  simp [nhdsWithin, map_add_left_nhds_zero x, Filter.map_inf, add_right_injective x]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
⊢ HasDerivAt f f' x ↔ Tendsto (fun t => t⁻¹ • (f (x + t) - f x)) (𝓝[≠] 0) (𝓝 f')
state_after: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
this : 𝓝[≠] x = map (fun t => x + t) (𝓝[≠] 0)
⊢ HasDerivAt f f' x ↔ Tendsto (fun t => t⁻¹ • (f (x + t) - f x)) (𝓝[≠] 0) (𝓝 f')

tactic: simp [hasDerivAt_iff_tendsto_slope, this, slope, Function.comp]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
this : 𝓝[≠] x = map (fun t => x + t) (𝓝[≠] 0)
⊢ HasDerivAt f f' x ↔ Tendsto (fun t => t⁻¹ • (f (x + t) - f x)) (𝓝[≠] 0) (𝓝 f')
state_after: no goals

tactic: simp [nhdsWithin, map_add_left_nhds_zero x, Filter.map_inf, add_right_injective x]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
⊢ 𝓝[≠] x = map (fun t => x + t) (𝓝[≠] 0)
state_after: no goals
Theorem: Bornology.IsBounded.thickening
File: Mathlib/Topology/MetricSpace/Thickening.lean

tactic: rcases E.eq_empty_or_nonempty with rfl | ⟨x, hx⟩
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x : α
X : Type u
inst✝ : PseudoMetricSpace X
δ : ℝ
E : Set X
h : Bornology.IsBounded E
⊢ Bornology.IsBounded (thickening δ E)
state_after: case inl
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x : α
X : Type u
inst✝ : PseudoMetricSpace X
δ : ℝ
h : Bornology.IsBounded ∅
⊢ Bornology.IsBounded (thickening δ ∅)

case inr.intro
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x✝ : α
X : Type u
inst✝ : PseudoMetricSpace X
δ : ℝ
E : Set X
h : Bornology.IsBounded E
x : X
hx : x ∈ E
⊢ Bornology.IsBounded (thickening δ E)

tactic: simp
state_before: case inl
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x : α
X : Type u
inst✝ : PseudoMetricSpace X
δ : ℝ
h : Bornology.IsBounded ∅
⊢ Bornology.IsBounded (thickening δ ∅)
state_after: no goals

tactic: refine (isBounded_iff_subset_closedBall x).2 ⟨δ + diam E, fun y hy ↦ ?_⟩
state_before: case inr.intro
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x✝ : α
X : Type u
inst✝ : PseudoMetricSpace X
δ : ℝ
E : Set X
h : Bornology.IsBounded E
x : X
hx : x ∈ E
⊢ Bornology.IsBounded (thickening δ E)
state_after: case inr.intro
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x✝ : α
X : Type u
inst✝ : PseudoMetricSpace X
δ : ℝ
E : Set X
h : Bornology.IsBounded E
x : X
hx : x ∈ E
y : X
hy : y ∈ thickening δ E
⊢ y ∈ closedBall x (δ + diam E)

tactic: calc
  dist y x ≤ infDist y E + diam E := dist_le_infDist_add_diam (x := y) h hx
  _ ≤ δ + diam E := add_le_add_right ((mem_thickening_iff_infDist_lt ⟨x, hx⟩).1 hy).le _
state_before: case inr.intro
ι : Sort u_1
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x✝ : α
X : Type u
inst✝ : PseudoMetricSpace X
δ : ℝ
E : Set X
h : Bornology.IsBounded E
x : X
hx : x ∈ E
y : X
hy : y ∈ thickening δ E
⊢ y ∈ closedBall x (δ + diam E)
state_after: no goals