1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: TendstoUniformlyOnFilter.prod_map
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: rw [tendstoUniformlyOnFilter_iff_tendsto] at h h' ⊢
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
ι' : Type u_1
α' : Type u_2
β' : Type u_3
inst✝ : UniformSpace β'
F' : ι' → α' → β'
f' : α' → β'
q : Filter ι'
q' : Filter α'
h : TendstoUniformlyOnFilter F f p p'
h' : TendstoUniformlyOnFilter F' f' q q'
⊢ TendstoUniformlyOnFilter (fun i => Prod.map (F i.1) (F' i.2)) (Prod.map f f') (p ×ˢ q) (p' ×ˢ q')
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
ι' : Type u_1
α' : Type u_2
β' : Type u_3
inst✝ : UniformSpace β'
F' : ι' → α' → β'
f' : α' → β'
q : Filter ι'
q' : Filter α'
h : Tendsto (fun q => (f q.2, F q.1 q.2)) (p ×ˢ p') (𝓤 β)
h' : Tendsto (fun q => (f' q.2, F' q.1 q.2)) (q ×ˢ q') (𝓤 β')
⊢ Tendsto (fun q => (Prod.map f f' q.2, Prod.map (F q.1.1) (F' q.1.2) q.2)) ((p ×ˢ q) ×ˢ p' ×ˢ q') (𝓤 (β × β'))

tactic: rw [uniformity_prod_eq_comap_prod, tendsto_comap_iff, ← map_swap4_prod, tendsto_map'_iff]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
ι' : Type u_1
α' : Type u_2
β' : Type u_3
inst✝ : UniformSpace β'
F' : ι' → α' → β'
f' : α' → β'
q : Filter ι'
q' : Filter α'
h : Tendsto (fun q => (f q.2, F q.1 q.2)) (p ×ˢ p') (𝓤 β)
h' : Tendsto (fun q => (f' q.2, F' q.1 q.2)) (q ×ˢ q') (𝓤 β')
⊢ Tendsto (fun q => (Prod.map f f' q.2, Prod.map (F q.1.1) (F' q.1.2) q.2)) ((p ×ˢ q) ×ˢ p' ×ˢ q') (𝓤 (β × β'))
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
ι' : Type u_1
α' : Type u_2
β' : Type u_3
inst✝ : UniformSpace β'
F' : ι' → α' → β'
f' : α' → β'
q : Filter ι'
q' : Filter α'
h : Tendsto (fun q => (f q.2, F q.1 q.2)) (p ×ˢ p') (𝓤 β)
h' : Tendsto (fun q => (f' q.2, F' q.1 q.2)) (q ×ˢ q') (𝓤 β')
⊢ Tendsto
    (((fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) ∘ fun q => (Prod.map f f' q.2, Prod.map (F q.1.1) (F' q.1.2) q.2)) ∘
      fun p => ((p.1.1, p.2.1), p.1.2, p.2.2))
    ((p ×ˢ p') ×ˢ q ×ˢ q') (𝓤 β ×ˢ 𝓤 β')

tactic: convert h.prod_map h'
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
ι' : Type u_1
α' : Type u_2
β' : Type u_3
inst✝ : UniformSpace β'
F' : ι' → α' → β'
f' : α' → β'
q : Filter ι'
q' : Filter α'
h : Tendsto (fun q => (f q.2, F q.1 q.2)) (p ×ˢ p') (𝓤 β)
h' : Tendsto (fun q => (f' q.2, F' q.1 q.2)) (q ×ˢ q') (𝓤 β')
⊢ Tendsto
    (((fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) ∘ fun q => (Prod.map f f' q.2, Prod.map (F q.1.1) (F' q.1.2) q.2)) ∘
      fun p => ((p.1.1, p.2.1), p.1.2, p.2.2))
    ((p ×ˢ p') ×ˢ q ×ˢ q') (𝓤 β ×ˢ 𝓤 β')
state_after: no goals
Theorem: FirstOrder.Language.withConstants_funMap_sum_inr
File: Mathlib/ModelTheory/LanguageMap.lean

tactic: rw [Unique.eq_default x]
state_before: L : Language
L' : Language
M : Type w
inst✝¹ : L.Structure M
α : Type u_1
inst✝ : (constantsOn α).Structure M
a : α
x : Fin 0 → M
⊢ funMap (Sum.inr a) x = ↑(L.con a)
state_after: L : Language
L' : Language
M : Type w
inst✝¹ : L.Structure M
α : Type u_1
inst✝ : (constantsOn α).Structure M
a : α
x : Fin 0 → M
⊢ funMap (Sum.inr a) default = ↑(L.con a)

tactic: exact (LHom.sumInr : constantsOn α →ᴸ L.sum _).map_onFunction _ _
state_before: L : Language
L' : Language
M : Type w
inst✝¹ : L.Structure M
α : Type u_1
inst✝ : (constantsOn α).Structure M
a : α
x : Fin 0 → M
⊢ funMap (Sum.inr a) default = ↑(L.con a)
state_after: no goals
Theorem: MeasureTheory.Submartingale.zero_le_of_predictable
File: Mathlib/Probability/Martingale/Basic.lean

tactic: induction' n with k ih
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁵ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝¹ : Preorder E
inst✝ : SigmaFiniteFiltration μ 𝒢
f : ℕ → Ω → E
hfmgle : Submartingale f 𝒢 μ
hfadp : Adapted 𝒢 fun n => f (n + 1)
n : ℕ
⊢ f 0 ≤ᶠ[ae μ] f n
state_after: case zero
Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁵ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝¹ : Preorder E
inst✝ : SigmaFiniteFiltration μ 𝒢
f : ℕ → Ω → E
hfmgle : Submartingale f 𝒢 μ
hfadp : Adapted 𝒢 fun n => f (n + 1)
⊢ f 0 ≤ᶠ[ae μ] f 0

case succ
Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁵ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝¹ : Preorder E
inst✝ : SigmaFiniteFiltration μ 𝒢
f : ℕ → Ω → E
hfmgle : Submartingale f 𝒢 μ
hfadp : Adapted 𝒢 fun n => f (n + 1)
k : ℕ
ih : f 0 ≤ᶠ[ae μ] f k
⊢ f 0 ≤ᶠ[ae μ] f (k + 1)

tactic: rfl
state_before: case zero
Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁵ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝¹ : Preorder E
inst✝ : SigmaFiniteFiltration μ 𝒢
f : ℕ → Ω → E
hfmgle : Submartingale f 𝒢 μ
hfadp : Adapted 𝒢 fun n => f (n + 1)
⊢ f 0 ≤ᶠ[ae μ] f 0
state_after: no goals

tactic: exact ih.trans ((hfmgle.2.1 k (k + 1) k.le_succ).trans_eq <| Germ.coe_eq.mp <|
congr_arg Germ.ofFun <| condexp_of_stronglyMeasurable (𝒢.le _) (hfadp _) <| hfmgle.integrable _)
state_before: case succ
Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁵ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝¹ : Preorder E
inst✝ : SigmaFiniteFiltration μ 𝒢
f : ℕ → Ω → E
hfmgle : Submartingale f 𝒢 μ
hfadp : Adapted 𝒢 fun n => f (n + 1)
k : ℕ
ih : f 0 ≤ᶠ[ae μ] f k
⊢ f 0 ≤ᶠ[ae μ] f (k + 1)
state_after: no goals
Theorem: CategoryTheory.Functor.ShiftSequence.induced.shiftIso_hom_app_obj
File: Mathlib/CategoryTheory/Shift/InducedShiftSequence.lean

tactic: simp
state_before: C : Type u_1
D : Type u_2
A : Type u_3
inst✝⁹ : Category.{u_7, u_1} C
inst✝⁸ : Category.{u_6, u_2} D
inst✝⁷ : Category.{u_5, u_3} A
L : C ⥤ D
F : D ⥤ A
G : C ⥤ A
e : L ⋙ F ≅ G
M : Type u_4
inst✝⁶ : AddMonoid M
inst✝⁵ : HasShift C M
inst✝⁴ : HasShift D M
inst✝³ : L.CommShift M
inst✝² : G.ShiftSequence M
F' : M → D ⥤ A
e' : (m : M) → L ⋙ F' m ≅ G.shift m
inst✝¹ : ((whiskeringLeft C D A).obj L).Full
inst✝ : ((whiskeringLeft C D A).obj L).Faithful
n a a' : M
ha' : n + a = a'
X : C
⊢ ((L.associator (shiftFunctor D n) (F' a)).symm ≪≫
            isoWhiskerRight (L.commShiftIso n).symm (F' a) ≪≫
              (shiftFunctor C n).associator L (F' a) ≪≫
                isoWhiskerLeft (shiftFunctor C n) (e' a) ≪≫ G.shiftIso n a a' ha' ≪≫ (e' a').symm).hom.app
      X =
    (F' a).map ((L.commShiftIso n).inv.app X) ≫
      (e' a).hom.app ((shiftFunctor C n).obj X) ≫ (G.shiftIso n a a' ha').hom.app X ≫ (e' a').inv.app X
state_after: no goals
Theorem: Set.mulIndicator_ae_eq_one
File: Mathlib/MeasureTheory/OuterMeasure/AE.lean

tactic: simp [EventuallyEq, eventually_iff, ae, compl_setOf]
state_before: α : Type u_1
β : Type u_2
F : Type u_3
inst✝² : FunLike F (Set α) ℝ≥0∞
inst✝¹ : OuterMeasureClass F α
μ : F
s✝ t : Set α
M : Type u_4
inst✝ : One M
f : α → M
s : Set α
⊢ s.mulIndicator f =ᶠ[ae μ] 1 ↔ μ (s ∩ Function.mulSupport f) = 0
state_after: α : Type u_1
β : Type u_2
F : Type u_3
inst✝² : FunLike F (Set α) ℝ≥0∞
inst✝¹ : OuterMeasureClass F α
μ : F
s✝ t : Set α
M : Type u_4
inst✝ : One M
f : α → M
s : Set α
⊢ μ {a | a ∈ s ∧ ¬f a = 1} = 0 ↔ μ (s ∩ Function.mulSupport f) = 0

tactic: rfl
state_before: α : Type u_1
β : Type u_2
F : Type u_3
inst✝² : FunLike F (Set α) ℝ≥0∞
inst✝¹ : OuterMeasureClass F α
μ : F
s✝ t : Set α
M : Type u_4
inst✝ : One M
f : α → M
s : Set α
⊢ μ {a | a ∈ s ∧ ¬f a = 1} = 0 ↔ μ (s ∩ Function.mulSupport f) = 0
state_after: no goals
Theorem: SimpleGraph.TripartiteFromTriangles.toTriangle_is3Clique
File: Mathlib/Combinatorics/SimpleGraph/Triangle/Tripartite.lean

tactic: simp only [toTriangle_apply, is3Clique_triple_iff, in₀₁_iff, in₀₂_iff, in₁₂_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝³ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DecidableEq γ
hx : x ∈ t
⊢ (graph t).IsNClique 3 (toTriangle x)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝³ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DecidableEq γ
hx : x ∈ t
⊢ (∃ c, (x.1, x.2.1, c) ∈ t) ∧ (∃ b, (x.1, b, x.2.2) ∈ t) ∧ ∃ a, (a, x.2.1, x.2.2) ∈ t

tactic: exact ⟨⟨_, hx⟩, ⟨_, hx⟩, _, hx⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝³ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DecidableEq γ
hx : x ∈ t
⊢ (∃ c, (x.1, x.2.1, c) ∈ t) ∧ (∃ b, (x.1, b, x.2.2) ∈ t) ∧ ∃ a, (a, x.2.1, x.2.2) ∈ t
state_after: no goals
Theorem: Polynomial.support_map_of_injective
File: Mathlib/Algebra/Polynomial/Eval.lean

tactic: simp_rw [Finset.ext_iff, mem_support_iff, coeff_map, ← map_zero f, hf.ne_iff,
  forall_const]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
inst✝ : Semiring S
p : R[X]
f : R →+* S
hf : Function.Injective ⇑f
⊢ (map f p).support = p.support
state_after: no goals
Theorem: deriv.lhopital_zero_atBot_on_Iio
File: Mathlib/Analysis/Calculus/LHopital.lean

tactic: have hdf : ∀ x ∈ Iio a, DifferentiableAt ℝ f x := fun x hx =>
  (hdf x hx).differentiableAt (Iio_mem_nhds hx)
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf : DifferentiableOn ℝ f (Iio a)
hg' : ∀ x ∈ Iio a, deriv g x ≠ 0
hfbot : Tendsto f atBot (𝓝 0)
hgbot : Tendsto g atBot (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) atBot l
⊢ Tendsto (fun x => f x / g x) atBot l
state_after: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf✝ : DifferentiableOn ℝ f (Iio a)
hg' : ∀ x ∈ Iio a, deriv g x ≠ 0
hfbot : Tendsto f atBot (𝓝 0)
hgbot : Tendsto g atBot (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) atBot l
hdf : ∀ x ∈ Iio a, DifferentiableAt ℝ f x
⊢ Tendsto (fun x => f x / g x) atBot l

tactic: have hdg : ∀ x ∈ Iio a, DifferentiableAt ℝ g x := fun x hx =>
  by_contradiction fun h => hg' x hx (deriv_zero_of_not_differentiableAt h)
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf✝ : DifferentiableOn ℝ f (Iio a)
hg' : ∀ x ∈ Iio a, deriv g x ≠ 0
hfbot : Tendsto f atBot (𝓝 0)
hgbot : Tendsto g atBot (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) atBot l
hdf : ∀ x ∈ Iio a, DifferentiableAt ℝ f x
⊢ Tendsto (fun x => f x / g x) atBot l
state_after: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf✝ : DifferentiableOn ℝ f (Iio a)
hg' : ∀ x ∈ Iio a, deriv g x ≠ 0
hfbot : Tendsto f atBot (𝓝 0)
hgbot : Tendsto g atBot (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) atBot l
hdf : ∀ x ∈ Iio a, DifferentiableAt ℝ f x
hdg : ∀ x ∈ Iio a, DifferentiableAt ℝ g x
⊢ Tendsto (fun x => f x / g x) atBot l

tactic: exact HasDerivAt.lhopital_zero_atBot_on_Iio (fun x hx => (hdf x hx).hasDerivAt)
  (fun x hx => (hdg x hx).hasDerivAt) hg' hfbot hgbot hdiv
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf✝ : DifferentiableOn ℝ f (Iio a)
hg' : ∀ x ∈ Iio a, deriv g x ≠ 0
hfbot : Tendsto f atBot (𝓝 0)
hgbot : Tendsto g atBot (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) atBot l
hdf : ∀ x ∈ Iio a, DifferentiableAt ℝ f x
hdg : ∀ x ∈ Iio a, DifferentiableAt ℝ g x
⊢ Tendsto (fun x => f x / g x) atBot l
state_after: no goals
Theorem: Algebraic.cardinal_mk_lift_le_max
File: Mathlib/Algebra/AlgebraicCard.lean

tactic: simp
state_before: R : Type u
A : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : IsDomain A
inst✝¹ : Algebra R A
inst✝ : NoZeroSMulDivisors R A
⊢ lift.{v, u} (max #R ℵ₀) * ℵ₀ ≤ max (lift.{v, u} #R) ℵ₀
state_after: no goals
Theorem: DirectSum.IsInternal.ofBijective_coeLinearMap_same
File: Mathlib/Algebra/DirectSum/Module.lean

tactic: rw [← coeLinearMap_of, LinearEquiv.ofBijective_symm_apply_apply, of_eq_same]
state_before: R : Type u
inst✝² : Semiring R
ι : Type v
dec_ι : DecidableEq ι
M : Type u_1
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
A : ι → Submodule R M
h : IsInternal A
i : ι
x : ↥(A i)
⊢ ((LinearEquiv.ofBijective (coeLinearMap A) h).symm ↑x) i = x
state_after: no goals
Theorem: List.rotate_perm
File: Mathlib/Data/List/Rotate.lean

tactic: rw [rotate_eq_rotate']
state_before: α : Type u
l : List α
n : ℕ
⊢ l.rotate n ~ l
state_after: α : Type u
l : List α
n : ℕ
⊢ l.rotate' n ~ l

tactic: induction' n with n hn generalizing l
state_before: α : Type u
l : List α
n : ℕ
⊢ l.rotate' n ~ l
state_after: case zero
α : Type u
l : List α
⊢ l.rotate' 0 ~ l

case succ
α : Type u
n : ℕ
hn : ∀ (l : List α), l.rotate' n ~ l
l : List α
⊢ l.rotate' (n + 1) ~ l

tactic: simp
state_before: case zero
α : Type u
l : List α
⊢ l.rotate' 0 ~ l
state_after: no goals

tactic: cases' l with hd tl
state_before: case succ
α : Type u
n : ℕ
hn : ∀ (l : List α), l.rotate' n ~ l
l : List α
⊢ l.rotate' (n + 1) ~ l
state_after: case succ.nil
α : Type u
n : ℕ
hn : ∀ (l : List α), l.rotate' n ~ l
⊢ [].rotate' (n + 1) ~ []

case succ.cons
α : Type u
n : ℕ
hn : ∀ (l : List α), l.rotate' n ~ l
hd : α
tl : List α
⊢ (hd :: tl).rotate' (n + 1) ~ hd :: tl

tactic: simp
state_before: case succ.nil
α : Type u
n : ℕ
hn : ∀ (l : List α), l.rotate' n ~ l
⊢ [].rotate' (n + 1) ~ []
state_after: no goals

tactic: rw [rotate'_cons_succ]
state_before: case succ.cons
α : Type u
n : ℕ
hn : ∀ (l : List α), l.rotate' n ~ l
hd : α
tl : List α
⊢ (hd :: tl).rotate' (n + 1) ~ hd :: tl
state_after: case succ.cons
α : Type u
n : ℕ
hn : ∀ (l : List α), l.rotate' n ~ l
hd : α
tl : List α
⊢ (tl ++ [hd]).rotate' n ~ hd :: tl

tactic: exact (hn _).trans (perm_append_singleton _ _)
state_before: case succ.cons
α : Type u
n : ℕ
hn : ∀ (l : List α), l.rotate' n ~ l
hd : α
tl : List α
⊢ (tl ++ [hd]).rotate' n ~ hd :: tl
state_after: no goals
Theorem: Ordinal.nfp_le_iff
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: rw [← sup_iterate_eq_nfp]
state_before: f : Ordinal.{u} → Ordinal.{u}
a b : Ordinal.{u}
⊢ nfp f a ≤ b ↔ ∀ (n : ℕ), f^[n] a ≤ b
state_after: f : Ordinal.{u} → Ordinal.{u}
a b : Ordinal.{u}
⊢ (fun a => sup fun n => f^[n] a) a ≤ b ↔ ∀ (n : ℕ), f^[n] a ≤ b

tactic: exact sup_le_iff
state_before: f : Ordinal.{u} → Ordinal.{u}
a b : Ordinal.{u}
⊢ (fun a => sup fun n => f^[n] a) a ≤ b ↔ ∀ (n : ℕ), f^[n] a ≤ b
state_after: no goals
Theorem: legendreSym.at_zero
File: Mathlib/NumberTheory/LegendreSymbol/Basic.lean

tactic: rw [legendreSym, Int.cast_zero, MulChar.map_zero]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
⊢ legendreSym p 0 = 0
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.map_addY
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: simp [addY, ← comp_fin3]
state_before: R : Type u
inst✝² : CommRing R
W' : Jacobian R
F : Type v
inst✝¹ : Field F
W : Jacobian F
S : Type u_1
inst✝ : CommRing S
f : R →+* S
P Q : Fin 3 → R
⊢ addY (map W' f) (⇑f ∘ P) (⇑f ∘ Q) = f (W'.addY P Q)
state_after: no goals
Theorem: MulAction.orbit.isBlock_of_normal
File: Mathlib/GroupTheory/GroupAction/Blocks.lean

tactic: rw [IsBlock.def_one]
state_before: G : Type u_1
inst✝² : Group G
X : Type u_2
inst✝¹ : MulAction G X
N : Subgroup G
inst✝ : N.Normal
a : X
⊢ IsBlock G (orbit (↥N) a)
state_after: G : Type u_1
inst✝² : Group G
X : Type u_2
inst✝¹ : MulAction G X
N : Subgroup G
inst✝ : N.Normal
a : X
⊢ ∀ (g : G), g • orbit (↥N) a = orbit (↥N) a ∨ Disjoint (g • orbit (↥N) a) (orbit (↥N) a)

tactic: intro g
state_before: G : Type u_1
inst✝² : Group G
X : Type u_2
inst✝¹ : MulAction G X
N : Subgroup G
inst✝ : N.Normal
a : X
⊢ ∀ (g : G), g • orbit (↥N) a = orbit (↥N) a ∨ Disjoint (g • orbit (↥N) a) (orbit (↥N) a)
state_after: G : Type u_1
inst✝² : Group G
X : Type u_2
inst✝¹ : MulAction G X
N : Subgroup G
inst✝ : N.Normal
a : X
g : G
⊢ g • orbit (↥N) a = orbit (↥N) a ∨ Disjoint (g • orbit (↥N) a) (orbit (↥N) a)

tactic: rw [smul_orbit_eq_orbit_smul]
state_before: G : Type u_1
inst✝² : Group G
X : Type u_2
inst✝¹ : MulAction G X
N : Subgroup G
inst✝ : N.Normal
a : X
g : G
⊢ g • orbit (↥N) a = orbit (↥N) a ∨ Disjoint (g • orbit (↥N) a) (orbit (↥N) a)
state_after: G : Type u_1
inst✝² : Group G
X : Type u_2
inst✝¹ : MulAction G X
N : Subgroup G
inst✝ : N.Normal
a : X
g : G
⊢ orbit (↥N) (g • a) = orbit (↥N) a ∨ Disjoint (orbit (↥N) (g • a)) (orbit (↥N) a)

tactic: apply orbit.eq_or_disjoint
state_before: G : Type u_1
inst✝² : Group G
X : Type u_2
inst✝¹ : MulAction G X
N : Subgroup G
inst✝ : N.Normal
a : X
g : G
⊢ orbit (↥N) (g • a) = orbit (↥N) a ∨ Disjoint (orbit (↥N) (g • a)) (orbit (↥N) a)
state_after: no goals
Theorem: Set.preimage_const_mul_Ioc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [← Ioi_inter_Iic, h]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
h : 0 < c
⊢ (fun x => c * x) ⁻¹' Ioc a b = Ioc (a / c) (b / c)
state_after: no goals
Theorem: PartENat.natCast_lt_top
File: Mathlib/Data/Nat/PartENat.lean

tactic: simp only [dom_natCast]
state_before: x : ℕ
h : ↑x = ⊤
⊢ ¬(↑x).Dom = ⊤.Dom
state_after: x : ℕ
h : ↑x = ⊤
⊢ ¬True = ⊤.Dom

tactic: exact true_ne_false
state_before: x : ℕ
h : ↑x = ⊤
⊢ ¬True = ⊤.Dom
state_after: no goals
Theorem: Sym.eq_replicate_iff
File: Mathlib/Data/Sym/Basic.lean

tactic: erw [Subtype.ext_iff, Multiset.eq_replicate]
state_before: α : Type u_1
β : Type u_2
n n' m : ℕ
s : Sym α n
a b : α
⊢ s = replicate n a ↔ ∀ b ∈ s, b = a
state_after: α : Type u_1
β : Type u_2
n n' m : ℕ
s : Sym α n
a b : α
⊢ (Multiset.card ↑s = n ∧ ∀ b ∈ ↑s, b = a) ↔ ∀ b ∈ s, b = a

tactic: exact and_iff_right s.2
state_before: α : Type u_1
β : Type u_2
n n' m : ℕ
s : Sym α n
a b : α
⊢ (Multiset.card ↑s = n ∧ ∀ b ∈ ↑s, b = a) ↔ ∀ b ∈ s, b = a
state_after: no goals
Theorem: Polynomial.coeff_mul_X
File: Mathlib/Algebra/Polynomial/Coeff.lean

tactic: simpa only [pow_one] using coeff_mul_X_pow p 1 n
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
n : ℕ
⊢ (p * X).coeff (n + 1) = p.coeff n
state_after: no goals
Theorem: EuclideanGeometry.exists_circumsphere_eq_of_cospherical_subset
File: Mathlib/Geometry/Euclidean/Circumcenter.lean

tactic: obtain ⟨r, hr⟩ := exists_circumradius_eq_of_cospherical_subset h hd hc
state_before: V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
ps : Set P
h : ps ⊆ ↑s
inst✝¹ : Nonempty ↥s
n : ℕ
inst✝ : FiniteDimensional ℝ ↥s.direction
hd : finrank ℝ ↥s.direction = n
hc : Cospherical ps
⊢ ∃ c, ∀ (sx : Simplex ℝ P n), Set.range sx.points ⊆ ps → sx.circumsphere = c
state_after: case intro
V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
ps : Set P
h : ps ⊆ ↑s
inst✝¹ : Nonempty ↥s
n : ℕ
inst✝ : FiniteDimensional ℝ ↥s.direction
hd : finrank ℝ ↥s.direction = n
hc : Cospherical ps
r : ℝ
hr : ∀ (sx : Simplex ℝ P n), Set.range sx.points ⊆ ps → sx.circumradius = r
⊢ ∃ c, ∀ (sx : Simplex ℝ P n), Set.range sx.points ⊆ ps → sx.circumsphere = c

tactic: obtain ⟨c, hc⟩ := exists_circumcenter_eq_of_cospherical_subset h hd hc
state_before: case intro
V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
ps : Set P
h : ps ⊆ ↑s
inst✝¹ : Nonempty ↥s
n : ℕ
inst✝ : FiniteDimensional ℝ ↥s.direction
hd : finrank ℝ ↥s.direction = n
hc : Cospherical ps
r : ℝ
hr : ∀ (sx : Simplex ℝ P n), Set.range sx.points ⊆ ps → sx.circumradius = r
⊢ ∃ c, ∀ (sx : Simplex ℝ P n), Set.range sx.points ⊆ ps → sx.circumsphere = c
state_after: case intro.intro
V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
ps : Set P
h : ps ⊆ ↑s
inst✝¹ : Nonempty ↥s
n : ℕ
inst✝ : FiniteDimensional ℝ ↥s.direction
hd : finrank ℝ ↥s.direction = n
hc✝ : Cospherical ps
r : ℝ
hr : ∀ (sx : Simplex ℝ P n), Set.range sx.points ⊆ ps → sx.circumradius = r
c : P
hc : ∀ (sx : Simplex ℝ P n), Set.range sx.points ⊆ ps → sx.circumcenter = c
⊢ ∃ c, ∀ (sx : Simplex ℝ P n), Set.range sx.points ⊆ ps → sx.circumsphere = c

tactic: exact ⟨⟨c, r⟩, fun sx hsx => Sphere.ext _ _ (hc sx hsx) (hr sx hsx)⟩
state_before: case intro.intro
V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
ps : Set P
h : ps ⊆ ↑s
inst✝¹ : Nonempty ↥s
n : ℕ
inst✝ : FiniteDimensional ℝ ↥s.direction
hd : finrank ℝ ↥s.direction = n
hc✝ : Cospherical ps
r : ℝ
hr : ∀ (sx : Simplex ℝ P n), Set.range sx.points ⊆ ps → sx.circumradius = r
c : P
hc : ∀ (sx : Simplex ℝ P n), Set.range sx.points ⊆ ps → sx.circumcenter = c
⊢ ∃ c, ∀ (sx : Simplex ℝ P n), Set.range sx.points ⊆ ps → sx.circumsphere = c
state_after: no goals
Theorem: Set.nontrivial_coe_sort
File: Mathlib/Data/Set/Subsingleton.lean

tactic: simp [← nontrivial_univ_iff, Set.Nontrivial]
state_before: α : Type u
a : α
s✝ t s : Set α
⊢ Nontrivial ↑s ↔ s.Nontrivial
state_after: no goals
Theorem: Ordinal.nadd_le_iff
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: rw [nadd_def]
state_before: a b c : Ordinal.{u}
⊢ b ♯ c ≤ a ↔ (∀ b' < b, b' ♯ c < a) ∧ ∀ c' < c, b ♯ c' < a
state_after: a b c : Ordinal.{u}
⊢ max (b.blsub fun a' x => a' ♯ c) (c.blsub fun b' x => b ♯ b') ≤ a ↔ (∀ b' < b, b' ♯ c < a) ∧ ∀ c' < c, b ♯ c' < a

tactic: simp [blsub_le_iff]
state_before: a b c : Ordinal.{u}
⊢ max (b.blsub fun a' x => a' ♯ c) (c.blsub fun b' x => b ♯ b') ≤ a ↔ (∀ b' < b, b' ♯ c < a) ∧ ∀ c' < c, b ♯ c' < a
state_after: no goals
Theorem: TypeVec.const_nil
File: Mathlib/Data/TypeVec.lean

tactic: ext i : 1
state_before: n : ℕ
β : Type u_1
x : β
α : TypeVec.{u_2} 0
⊢ TypeVec.const x α = nilFun
state_after: case a
n : ℕ
β : Type u_1
x : β
α : TypeVec.{u_2} 0
i : Fin2 0
⊢ TypeVec.const x α i = nilFun i

tactic: cases i
state_before: case a
n : ℕ
β : Type u_1
x : β
α : TypeVec.{u_2} 0
i : Fin2 0
⊢ TypeVec.const x α i = nilFun i
state_after: no goals
Theorem: CategoryTheory.Limits.image.factorThruImage_preComp
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: simp [image.preComp]
state_before: C : Type u
inst✝² : Category.{v, u} C
X Y : C
f : X ⟶ Y
Z : C
g : Y ⟶ Z
inst✝¹ : HasImage g
inst✝ : HasImage (f ≫ g)
⊢ factorThruImage (f ≫ g) ≫ preComp f g = f ≫ factorThruImage g
state_after: no goals
Theorem: le_div_self_iff
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: simp [div_eq_mul_inv]
state_before: α : Type u
inst✝³ : Group α
inst✝² : LE α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ c d a b : α
⊢ a ≤ a / b ↔ b ≤ 1
state_after: no goals
Theorem: Set.equitableOn_iff_exists_image_subset_icc
File: Mathlib/Data/Set/Equitable.lean

tactic: simpa only [image_subset_iff] using equitableOn_iff_exists_le_le_add_one
state_before: α : Type u_1
β : Type u_2
s : Set α
f : α → ℕ
⊢ s.EquitableOn f ↔ ∃ b, f '' s ⊆ Icc b (b + 1)
state_after: no goals
Theorem: Associates.count_self
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: simp [factors_self hp, Associates.count_some hp]
state_before: α : Type u_1
inst✝⁵ : CancelCommMonoidWithZero α
inst✝⁴ : UniqueFactorizationMonoid α
inst✝³ : DecidableEq (Associates α)
inst✝² : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : Nontrivial α
inst✝ : DecidableEq (Associates α)
p : Associates α
hp : Irreducible p
⊢ p.count p.factors = 1
state_after: no goals