1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: EuclideanGeometry.dist_center_eq_dist_center_of_mem_sphere
File: Mathlib/Geometry/Euclidean/Sphere/Basic.lean

tactic: rw [mem_sphere.1 hp₁, mem_sphere.1 hp₂]
state_before: V : Type u_1
P : Type u_2
inst✝ : MetricSpace P
p₁ p₂ : P
s : Sphere P
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
⊢ dist p₁ s.center = dist p₂ s.center
state_after: no goals
Theorem: Real.one_le_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [Real.pi, mul_div_cancel_left₀ _ (two_ne_zero' ℝ)]
state_before: ⊢ 1 ≤ π / 2
state_after: ⊢ 1 ≤ Classical.choose exists_cos_eq_zero

tactic: exact (Classical.choose_spec exists_cos_eq_zero).1.1
state_before: ⊢ 1 ≤ Classical.choose exists_cos_eq_zero
state_after: no goals
Theorem: GeneralizedContinuedFraction.exists_s_a_of_part_num
File: Mathlib/Algebra/ContinuedFractions/Translations.lean

tactic: simpa [partialNumerators, Stream'.Seq.map_get?] using nth_part_num_eq
state_before: α : Type u_1
g : GeneralizedContinuedFraction α
n : ℕ
a : α
nth_part_num_eq : g.partialNumerators.get? n = some a
⊢ ∃ gp, g.s.get? n = some gp ∧ gp.a = a
state_after: no goals
Theorem: SimpleGraph.Subgraph.mem_verts_if_mem_edge
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: induction e
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : G.Subgraph
e : Sym2 V
v : V
he : e ∈ G'.edgeSet
hv : v ∈ e
⊢ v ∈ G'.verts
state_after: case h
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : G.Subgraph
v x✝ y✝ : V
he : s(x✝, y✝) ∈ G'.edgeSet
hv : v ∈ s(x✝, y✝)
⊢ v ∈ G'.verts

tactic: rcases Sym2.mem_iff.mp hv with (rfl | rfl)
state_before: case h
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : G.Subgraph
v x✝ y✝ : V
he : s(x✝, y✝) ∈ G'.edgeSet
hv : v ∈ s(x✝, y✝)
⊢ v ∈ G'.verts
state_after: case h.inl
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : G.Subgraph
v y✝ : V
he : s(v, y✝) ∈ G'.edgeSet
hv : v ∈ s(v, y✝)
⊢ v ∈ G'.verts

case h.inr
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : G.Subgraph
v x✝ : V
he : s(x✝, v) ∈ G'.edgeSet
hv : v ∈ s(x✝, v)
⊢ v ∈ G'.verts

tactic: exact G'.edge_vert he
state_before: case h.inl
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : G.Subgraph
v y✝ : V
he : s(v, y✝) ∈ G'.edgeSet
hv : v ∈ s(v, y✝)
⊢ v ∈ G'.verts
state_after: no goals

tactic: exact G'.edge_vert (G'.symm he)
state_before: case h.inr
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
G' : G.Subgraph
v x✝ : V
he : s(x✝, v) ∈ G'.edgeSet
hv : v ∈ s(x✝, v)
⊢ v ∈ G'.verts
state_after: no goals
Theorem: Polynomial.support_restriction
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: ext i
state_before: R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
⊢ p.restriction.support = p.support
state_after: case a
R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
i : ℕ
⊢ i ∈ p.restriction.support ↔ i ∈ p.support

tactic: simp only [mem_support_iff, not_iff_not, Ne]
state_before: case a
R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
i : ℕ
⊢ i ∈ p.restriction.support ↔ i ∈ p.support
state_after: case a
R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
i : ℕ
⊢ p.restriction.coeff i = 0 ↔ p.coeff i = 0

tactic: conv_rhs => rw [← coeff_restriction]
state_before: case a
R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
i : ℕ
⊢ p.restriction.coeff i = 0 ↔ p.coeff i = 0
state_after: case a
R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
i : ℕ
⊢ p.restriction.coeff i = 0 ↔ ↑(p.restriction.coeff i) = 0

tactic: exact ⟨fun H => by rw [H, ZeroMemClass.coe_zero], fun H => Subtype.coe_injective H⟩
state_before: case a
R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
i : ℕ
⊢ p.restriction.coeff i = 0 ↔ ↑(p.restriction.coeff i) = 0
state_after: no goals

tactic: rw [H, ZeroMemClass.coe_zero]
state_before: R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
i : ℕ
H : p.restriction.coeff i = 0
⊢ ↑(p.restriction.coeff i) = 0
state_after: no goals
Theorem: symmDiff_of_le
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff, sdiff_eq_bot_iff.2 h, bot_sup_eq]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a✝ b✝ c d a b : α
h : a ≤ b
⊢ a ∆ b = b \ a
state_after: no goals
Theorem: norm_mk_lt'
File: Mathlib/Analysis/Normed/Group/Quotient.lean

tactic: obtain ⟨n : M, hn : mk' S n = mk' S m, hn' : ‖n‖ < ‖mk' S m‖ + ε⟩ :=
  norm_mk_lt (QuotientAddGroup.mk' S m) hε
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
m : M
ε : ℝ
hε : 0 < ε
⊢ ∃ s ∈ S, ‖m + s‖ < ‖(mk' S) m‖ + ε
state_after: case intro.intro
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
m : M
ε : ℝ
hε : 0 < ε
n : M
hn : (mk' S) n = (mk' S) m
hn' : ‖n‖ < ‖(mk' S) m‖ + ε
⊢ ∃ s ∈ S, ‖m + s‖ < ‖(mk' S) m‖ + ε

tactic: erw [eq_comm, QuotientAddGroup.eq] at hn
state_before: case intro.intro
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
m : M
ε : ℝ
hε : 0 < ε
n : M
hn : (mk' S) n = (mk' S) m
hn' : ‖n‖ < ‖(mk' S) m‖ + ε
⊢ ∃ s ∈ S, ‖m + s‖ < ‖(mk' S) m‖ + ε
state_after: case intro.intro
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
m : M
ε : ℝ
hε : 0 < ε
n : M
hn : -m + n ∈ S
hn' : ‖n‖ < ‖(mk' S) m‖ + ε
⊢ ∃ s ∈ S, ‖m + s‖ < ‖(mk' S) m‖ + ε

tactic: use -m + n, hn
state_before: case intro.intro
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
m : M
ε : ℝ
hε : 0 < ε
n : M
hn : -m + n ∈ S
hn' : ‖n‖ < ‖(mk' S) m‖ + ε
⊢ ∃ s ∈ S, ‖m + s‖ < ‖(mk' S) m‖ + ε
state_after: case right
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
m : M
ε : ℝ
hε : 0 < ε
n : M
hn : -m + n ∈ S
hn' : ‖n‖ < ‖(mk' S) m‖ + ε
⊢ ‖m + (-m + n)‖ < ‖(mk' S) m‖ + ε

tactic: rwa [add_neg_cancel_left]
state_before: case right
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
m : M
ε : ℝ
hε : 0 < ε
n : M
hn : -m + n ∈ S
hn' : ‖n‖ < ‖(mk' S) m‖ + ε
⊢ ‖m + (-m + n)‖ < ‖(mk' S) m‖ + ε
state_after: no goals
Theorem: CategoryTheory.Limits.Bicone.π_of_isColimit
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: rw [ht.fac]
state_before: J : Type w
C : Type uC
inst✝³ : Category.{uC', uC} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
F f : J → C
t : Bicone f
ht : IsColimit t.toCocone
j : J
j' : Discrete J
⊢ t.toCocone.ι.app j' ≫ t.π j =
    t.toCocone.ι.app j' ≫ ht.desc (Cofan.mk (f j) fun j' => if h : j' = j then eqToHom ⋯ else 0)
state_after: J : Type w
C : Type uC
inst✝³ : Category.{uC', uC} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
F f : J → C
t : Bicone f
ht : IsColimit t.toCocone
j : J
j' : Discrete J
⊢ t.toCocone.ι.app j' ≫ t.π j = (Cofan.mk (f j) fun j' => if h : j' = j then eqToHom ⋯ else 0).ι.app j'

tactic: simp [t.ι_π]
state_before: J : Type w
C : Type uC
inst✝³ : Category.{uC', uC} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
F f : J → C
t : Bicone f
ht : IsColimit t.toCocone
j : J
j' : Discrete J
⊢ t.toCocone.ι.app j' ≫ t.π j = (Cofan.mk (f j) fun j' => if h : j' = j then eqToHom ⋯ else 0).ι.app j'
state_after: no goals
Theorem: IsIntegral.map_of_comp_eq
File: Mathlib/RingTheory/IntegralClosure.lean

tactic: rw [← eval_map, map_map, h, ← map_map, eval_map, eval₂_at_apply, eval_map, hp.2, ψ.map_zero]
state_before: R✝ : Type u_1
A : Type u_2
B : Type u_3
S✝ : Type u_4
inst✝¹¹ : CommRing R✝
inst✝¹⁰ : CommRing A
inst✝⁹ : Ring B
inst✝⁸ : CommRing S✝
inst✝⁷ : Algebra R✝ A
inst✝⁶ : Algebra R✝ B
f : R✝ →+* S✝
R : Type u_5
S : Type u_6
T : Type u_7
U : Type u_8
inst✝⁵ : CommRing R
inst✝⁴ : Ring S
inst✝³ : CommRing T
inst✝² : Ring U
inst✝¹ : Algebra R S
inst✝ : Algebra T U
φ : R →+* T
ψ : S →+* U
h : (algebraMap T U).comp φ = ψ.comp (algebraMap R S)
a : S
ha : IsIntegral R a
p : R[X]
hp : p.Monic ∧ eval₂ (algebraMap R S) a p = 0
⊢ eval₂ (algebraMap T U) (ψ a) (Polynomial.map φ p) = 0
state_after: no goals
Theorem: MeasureTheory.aemeasurable_of_pdf_ne_zero
File: Mathlib/Probability/Density.lean

tactic: contrapose! h
state_before: Ω : Type u_1
E : Type u_2
inst✝ : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
X : Ω → E
h : ¬pdf X ℙ μ =ᶠ[ae μ] 0
⊢ AEMeasurable X ℙ
state_after: Ω : Type u_1
E : Type u_2
inst✝ : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
X : Ω → E
h : ¬AEMeasurable X ℙ
⊢ pdf X ℙ μ =ᶠ[ae μ] 0

tactic: exact pdf_of_not_aemeasurable h
state_before: Ω : Type u_1
E : Type u_2
inst✝ : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
X : Ω → E
h : ¬AEMeasurable X ℙ
⊢ pdf X ℙ μ =ᶠ[ae μ] 0
state_after: no goals
Theorem: GaussianInt.intCast_complex_norm
File: Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean

tactic: cases x
state_before: x : ℤ[i]
⊢ ↑(norm x) = ↑(normSq (toComplex x))
state_after: case mk
re✝ im✝ : ℤ
⊢ ↑{ re := re✝, im := im✝ }.norm = ↑(normSq (toComplex { re := re✝, im := im✝ }))

tactic: rw [Zsqrtd.norm, normSq]
state_before: case mk
re✝ im✝ : ℤ
⊢ ↑{ re := re✝, im := im✝ }.norm = ↑(normSq (toComplex { re := re✝, im := im✝ }))
state_after: case mk
re✝ im✝ : ℤ
⊢ ↑({ re := re✝, im := im✝ }.re * { re := re✝, im := im✝ }.re -
        -1 * { re := re✝, im := im✝ }.im * { re := re✝, im := im✝ }.im) =
    ↑({ toFun := fun z => z.re * z.re + z.im * z.im, map_zero' := normSq.proof_1, map_one' := normSq.proof_2,
          map_mul' := normSq.proof_3 }
        (toComplex { re := re✝, im := im✝ }))

tactic: simp
state_before: case mk
re✝ im✝ : ℤ
⊢ ↑({ re := re✝, im := im✝ }.re * { re := re✝, im := im✝ }.re -
        -1 * { re := re✝, im := im✝ }.im * { re := re✝, im := im✝ }.im) =
    ↑({ toFun := fun z => z.re * z.re + z.im * z.im, map_zero' := normSq.proof_1, map_one' := normSq.proof_2,
          map_mul' := normSq.proof_3 }
        (toComplex { re := re✝, im := im✝ }))
state_after: no goals
Theorem: Fin.cast_eq_cast'
File: Mathlib/Data/Fintype/Card.lean

tactic: cases fin_injective h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
n m : ℕ
h : Fin n = Fin m
⊢ _root_.cast h = cast ⋯
state_after: case refl
α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
h : Fin n = Fin n
⊢ _root_.cast h = cast ⋯

tactic: rfl
state_before: case refl
α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
h : Fin n = Fin n
⊢ _root_.cast h = cast ⋯
state_after: no goals
Theorem: AlgebraicGeometry.ProjectiveSpectrum.Proj.toSpec_base_isIso
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean

tactic: convert (projIsoSpecTopComponent f_deg hm).isIso_hom
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
⊢ IsIso (toSpec 𝒜 f).val.base
state_after: case h.e'_5
R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
⊢ (toSpec 𝒜 f).val.base = (projIsoSpecTopComponent f_deg hm).hom

tactic: exact DFunLike.ext _ _ <| toSpec_base_apply_eq 𝒜
state_before: case h.e'_5
R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
hm : 0 < m
⊢ (toSpec 𝒜 f).val.base = (projIsoSpecTopComponent f_deg hm).hom
state_after: no goals
Theorem: MvPowerSeries.inv_eq_iff_mul_eq_one
File: Mathlib/RingTheory/MvPowerSeries/Inverse.lean

tactic: rw [eq_comm, MvPowerSeries.eq_inv_iff_mul_eq_one h]
state_before: σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
φ ψ : MvPowerSeries σ k
h : (constantCoeff σ k) ψ ≠ 0
⊢ ψ⁻¹ = φ ↔ φ * ψ = 1
state_after: no goals
Theorem: Filter.cardinalInter_ofCardinalGenerate
File: Mathlib/Order/Filter/CardinalInter.lean

tactic: delta cardinalGenerate
state_before: ι α β : Type u
c : Cardinal.{u}
l : Filter α
inst✝ : CardinalInterFilter l c
g : Set (Set α)
hc : 2 < c
⊢ CardinalInterFilter (cardinalGenerate g hc) c
state_after: ι α β : Type u
c : Cardinal.{u}
l : Filter α
inst✝ : CardinalInterFilter l c
g : Set (Set α)
hc : 2 < c
⊢ CardinalInterFilter (ofCardinalInter (CardinalGenerateSets g) hc ⋯ ⋯) c

tactic: apply cardinalInter_ofCardinalInter _ _ _
state_before: ι α β : Type u
c : Cardinal.{u}
l : Filter α
inst✝ : CardinalInterFilter l c
g : Set (Set α)
hc : 2 < c
⊢ CardinalInterFilter (ofCardinalInter (CardinalGenerateSets g) hc ⋯ ⋯) c
state_after: no goals
Theorem: CategoryTheory.Limits.prod.map_comp_id
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: simp
state_before: C : Type u
inst✝³ : Category.{v, u} C
X✝ Y✝ X Y Z W : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝² : HasBinaryProduct X W
inst✝¹ : HasBinaryProduct Z W
inst✝ : HasBinaryProduct Y W
⊢ map (f ≫ g) (𝟙 W) = map f (𝟙 W) ≫ map g (𝟙 W)
state_after: no goals
Theorem: Set.iUnion_eq_range_sigma
File: Mathlib/Data/Set/Lattice.lean

tactic: simp [Set.ext_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : α → Set β
⊢ ⋃ i, s i = range fun a => ↑a.snd
state_after: no goals
Theorem: List.rtake_eq_reverse_take_reverse
File: Mathlib/Data/List/DropRight.lean

tactic: rw [rtake]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ l.rtake n = (take n l.reverse).reverse
state_after: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ drop (l.length - n) l = (take n l.reverse).reverse

tactic: induction' l using List.reverseRecOn with xs x IH generalizing n
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ drop (l.length - n) l = (take n l.reverse).reverse
state_after: case nil
α : Type u_1
p : α → Bool
n : ℕ
⊢ drop ([].length - n) [] = (take n [].reverse).reverse

case append_singleton
α : Type u_1
p : α → Bool
xs : List α
x : α
IH : ∀ (n : ℕ), drop (xs.length - n) xs = (take n xs.reverse).reverse
n : ℕ
⊢ drop ((xs ++ [x]).length - n) (xs ++ [x]) = (take n (xs ++ [x]).reverse).reverse

tactic: simp
state_before: case nil
α : Type u_1
p : α → Bool
n : ℕ
⊢ drop ([].length - n) [] = (take n [].reverse).reverse
state_after: no goals

tactic: cases n
state_before: case append_singleton
α : Type u_1
p : α → Bool
xs : List α
x : α
IH : ∀ (n : ℕ), drop (xs.length - n) xs = (take n xs.reverse).reverse
n : ℕ
⊢ drop ((xs ++ [x]).length - n) (xs ++ [x]) = (take n (xs ++ [x]).reverse).reverse
state_after: case append_singleton.zero
α : Type u_1
p : α → Bool
xs : List α
x : α
IH : ∀ (n : ℕ), drop (xs.length - n) xs = (take n xs.reverse).reverse
⊢ drop ((xs ++ [x]).length - 0) (xs ++ [x]) = (take 0 (xs ++ [x]).reverse).reverse

case append_singleton.succ
α : Type u_1
p : α → Bool
xs : List α
x : α
IH : ∀ (n : ℕ), drop (xs.length - n) xs = (take n xs.reverse).reverse
n✝ : ℕ
⊢ drop ((xs ++ [x]).length - (n✝ + 1)) (xs ++ [x]) = (take (n✝ + 1) (xs ++ [x]).reverse).reverse

tactic: exact drop_length _
state_before: case append_singleton.zero
α : Type u_1
p : α → Bool
xs : List α
x : α
IH : ∀ (n : ℕ), drop (xs.length - n) xs = (take n xs.reverse).reverse
⊢ drop ((xs ++ [x]).length - 0) (xs ++ [x]) = (take 0 (xs ++ [x]).reverse).reverse
state_after: no goals

tactic: simp [drop_append_eq_append_drop, IH]
state_before: case append_singleton.succ
α : Type u_1
p : α → Bool
xs : List α
x : α
IH : ∀ (n : ℕ), drop (xs.length - n) xs = (take n xs.reverse).reverse
n✝ : ℕ
⊢ drop ((xs ++ [x]).length - (n✝ + 1)) (xs ++ [x]) = (take (n✝ + 1) (xs ++ [x]).reverse).reverse
state_after: no goals
Theorem: WithBot.unbot'_lt_iff
File: Mathlib/Order/WithBot.lean

tactic: induction a
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b✝ : α
inst✝ : LT α
a : WithBot α
b c : α
h : a = ⊥ → b < c
⊢ unbot' b a < c ↔ a < ↑c
state_after: case bot
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b✝ : α
inst✝ : LT α
b c : α
h : ⊥ = ⊥ → b < c
⊢ unbot' b ⊥ < c ↔ ⊥ < ↑c

case coe
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b✝ : α
inst✝ : LT α
b c a✝ : α
h : ↑a✝ = ⊥ → b < c
⊢ unbot' b ↑a✝ < c ↔ ↑a✝ < ↑c

tactic: simpa [bot_lt_coe] using h rfl
state_before: case bot
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b✝ : α
inst✝ : LT α
b c : α
h : ⊥ = ⊥ → b < c
⊢ unbot' b ⊥ < c ↔ ⊥ < ↑c
state_after: no goals

tactic: simp
state_before: case coe
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b✝ : α
inst✝ : LT α
b c a✝ : α
h : ↑a✝ = ⊥ → b < c
⊢ unbot' b ↑a✝ < c ↔ ↑a✝ < ↑c
state_after: no goals
Theorem: BoxIntegral.Box.coe_splitUpper
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

tactic: rw [splitUpper, coe_mk']
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I : Box ι
i : ι
x : ℝ
y : ι → ℝ
⊢ ↑(I.splitUpper i x) = ↑I ∩ {y | x < y i}
state_after: ι : Type u_1
M : Type u_2
n : ℕ
I : Box ι
i : ι
x : ℝ
y : ι → ℝ
⊢ (univ.pi fun i_1 => Ioc (update I.lower i (max x (I.lower i)) i_1) (I.upper i_1)) = ↑I ∩ {y | x < y i}

tactic: ext y
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I : Box ι
i : ι
x : ℝ
y : ι → ℝ
⊢ (univ.pi fun i_1 => Ioc (update I.lower i (max x (I.lower i)) i_1) (I.upper i_1)) = ↑I ∩ {y | x < y i}
state_after: case h
ι : Type u_1
M : Type u_2
n : ℕ
I : Box ι
i : ι
x : ℝ
y✝ y : ι → ℝ
⊢ (y ∈ univ.pi fun i_1 => Ioc (update I.lower i (max x (I.lower i)) i_1) (I.upper i_1)) ↔ y ∈ ↑I ∩ {y | x < y i}

tactic: simp only [mem_univ_pi, mem_Ioc, mem_inter_iff, mem_coe, mem_setOf_eq, forall_and,
  forall_update_iff I.lower fun j z => z < y j, max_lt_iff, and_assoc (a := x < y i),
  and_forall_ne (p := fun j => lower I j < y j) i, mem_def]
state_before: case h
ι : Type u_1
M : Type u_2
n : ℕ
I : Box ι
i : ι
x : ℝ
y✝ y : ι → ℝ
⊢ (y ∈ univ.pi fun i_1 => Ioc (update I.lower i (max x (I.lower i)) i_1) (I.upper i_1)) ↔ y ∈ ↑I ∩ {y | x < y i}
state_after: case h
ι : Type u_1
M : Type u_2
n : ℕ
I : Box ι
i : ι
x : ℝ
y✝ y : ι → ℝ
⊢ (x < y i ∧ (∀ (b : ι), I.lower b < y b) ∧ ∀ (x : ι), y x ≤ I.upper x) ↔
    ((∀ (x : ι), I.lower x < y x) ∧ ∀ (x : ι), y x ≤ I.upper x) ∧ x < y i

tactic: exact and_comm
state_before: case h
ι : Type u_1
M : Type u_2
n : ℕ
I : Box ι
i : ι
x : ℝ
y✝ y : ι → ℝ
⊢ (x < y i ∧ (∀ (b : ι), I.lower b < y b) ∧ ∀ (x : ι), y x ≤ I.upper x) ↔
    ((∀ (x : ι), I.lower x < y x) ∧ ∀ (x : ι), y x ≤ I.upper x) ∧ x < y i
state_after: no goals
Theorem: Polynomial.modByMonic_one
File: Mathlib/Algebra/Polynomial/Div.lean

tactic: convert monic_one (R := R)
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q p : R[X]
⊢ Monic 1
state_after: no goals
Theorem: gauge_eq_zero
File: Mathlib/Analysis/Convex/Gauge.lean

tactic: refine ⟨fun h₀ ↦ by_contra fun (hne : x ≠ 0) ↦ ?_, fun h ↦ h.symm ▸ gauge_zero⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
s t : Set E
x : E
a : ℝ
inst✝¹ : TopologicalSpace E
inst✝ : T1Space E
hs : Absorbent ℝ s
hb : Bornology.IsVonNBounded ℝ s
⊢ gauge s x = 0 ↔ x = 0
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
s t : Set E
x : E
a : ℝ
inst✝¹ : TopologicalSpace E
inst✝ : T1Space E
hs : Absorbent ℝ s
hb : Bornology.IsVonNBounded ℝ s
h₀ : gauge s x = 0
hne : x ≠ 0
⊢ False

tactic: have : {x}ᶜ ∈ comap (gauge s) (𝓝 0) :=
  comap_gauge_nhds_zero_le hs hb (isOpen_compl_singleton.mem_nhds hne.symm)
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
s t : Set E
x : E
a : ℝ
inst✝¹ : TopologicalSpace E
inst✝ : T1Space E
hs : Absorbent ℝ s
hb : Bornology.IsVonNBounded ℝ s
h₀ : gauge s x = 0
hne : x ≠ 0
⊢ False
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
s t : Set E
x : E
a : ℝ
inst✝¹ : TopologicalSpace E
inst✝ : T1Space E
hs : Absorbent ℝ s
hb : Bornology.IsVonNBounded ℝ s
h₀ : gauge s x = 0
hne : x ≠ 0
this : {x}ᶜ ∈ comap (gauge s) (𝓝 0)
⊢ False

tactic: rcases ((nhds_basis_zero_abs_sub_lt _).comap _).mem_iff.1 this with ⟨r, hr₀, hr⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
s t : Set E
x : E
a : ℝ
inst✝¹ : TopologicalSpace E
inst✝ : T1Space E
hs : Absorbent ℝ s
hb : Bornology.IsVonNBounded ℝ s
h₀ : gauge s x = 0
hne : x ≠ 0
this : {x}ᶜ ∈ comap (gauge s) (𝓝 0)
⊢ False
state_after: case intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
s t : Set E
x : E
a : ℝ
inst✝¹ : TopologicalSpace E
inst✝ : T1Space E
hs : Absorbent ℝ s
hb : Bornology.IsVonNBounded ℝ s
h₀ : gauge s x = 0
hne : x ≠ 0
this : {x}ᶜ ∈ comap (gauge s) (𝓝 0)
r : ℝ
hr₀ : 0 < r
hr : gauge s ⁻¹' {b | |b| < r} ⊆ {x}ᶜ
⊢ False

tactic: exact hr (by simpa [h₀]) rfl
state_before: case intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
s t : Set E
x : E
a : ℝ
inst✝¹ : TopologicalSpace E
inst✝ : T1Space E
hs : Absorbent ℝ s
hb : Bornology.IsVonNBounded ℝ s
h₀ : gauge s x = 0
hne : x ≠ 0
this : {x}ᶜ ∈ comap (gauge s) (𝓝 0)
r : ℝ
hr₀ : 0 < r
hr : gauge s ⁻¹' {b | |b| < r} ⊆ {x}ᶜ
⊢ False
state_after: no goals

tactic: simpa [h₀]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝³ : AddCommGroup E
inst✝² : Module ℝ E
s t : Set E
x : E
a : ℝ
inst✝¹ : TopologicalSpace E
inst✝ : T1Space E
hs : Absorbent ℝ s
hb : Bornology.IsVonNBounded ℝ s
h₀ : gauge s x = 0
hne : x ≠ 0
this : {x}ᶜ ∈ comap (gauge s) (𝓝 0)
r : ℝ
hr₀ : 0 < r
hr : gauge s ⁻¹' {b | |b| < r} ⊆ {x}ᶜ
⊢ x ∈ gauge s ⁻¹' {b | |b| < r}
state_after: no goals
Theorem: Mathlib.Tactic.RingNF.rat_rawCast_neg
File: Mathlib/Tactic/Ring/RingNF.lean

tactic: simp
state_before: R✝ : Type ?u.21568
inst✝¹ : CommSemiring R✝
n d : ℕ
R : Type u_1
inst✝ : DivisionRing R
⊢ Rat.rawCast (Int.negOfNat n) d = (Int.negOfNat n).rawCast / d.rawCast
state_after: no goals
Theorem: Mathlib.Tactic.Abel.const_add_term
File: Mathlib/Tactic/Abel.lean

tactic: simp [h.symm, term, add_comm, add_assoc]
state_before: α : Type u_1
inst✝ : AddCommMonoid α
k : α
n : ℕ
x a a' : α
h : k + a = a'
⊢ k + term n x a = term n x a'
state_after: no goals
Theorem: Real.cos_two_mul'
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [cos_two_mul']
state_before: x y : ℝ
⊢ ↑(cos (2 * x)) = ↑(cos x ^ 2 - sin x ^ 2)
state_after: no goals
Theorem: Mathlib.Meta.NormNum.jacobiSymNat.one_right
File: Mathlib/Tactic/NormNum/LegendreSymbol.lean

tactic: rw [jacobiSymNat, jacobiSym.one_right]
state_before: a : ℕ
⊢ jacobiSymNat a 1 = 1
state_after: no goals
Theorem: ENNReal.tsum_coe_ne_top_iff_summable_coe
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: rw [NNReal.summable_coe]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f : α → ℝ≥0
⊢ ∑' (a : α), ↑(f a) ≠ ⊤ ↔ Summable fun a => ↑(f a)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f : α → ℝ≥0
⊢ ∑' (a : α), ↑(f a) ≠ ⊤ ↔ Summable f

tactic: exact tsum_coe_ne_top_iff_summable
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f : α → ℝ≥0
⊢ ∑' (a : α), ↑(f a) ≠ ⊤ ↔ Summable f
state_after: no goals
Theorem: CategoryTheory.Limits.Multifork.condition
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

tactic: rw [← app_right_eq_ι_comp_fst, ← app_right_eq_ι_comp_snd]
state_before: C : Type u
inst✝ : Category.{v, u} C
I : MulticospanIndex C
K : Multifork I
b : I.R
⊢ K.ι (I.fstTo b) ≫ I.fst b = K.ι (I.sndTo b) ≫ I.snd b
state_after: no goals