1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: measurableSet_region_between_co
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: dsimp only [regionBetween, Ico, mem_setOf_eq, setOf_and]
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
f g : α → ℝ
s : Set α
hf : Measurable f
hg : Measurable g
hs : MeasurableSet s
⊢ MeasurableSet {p | p.1 ∈ s ∧ p.2 ∈ Ico (f p.1) (g p.1)}
state_after: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
f g : α → ℝ
s : Set α
hf : Measurable f
hg : Measurable g
hs : MeasurableSet s
⊢ MeasurableSet ({a | a.1 ∈ s} ∩ {a | a.2 ∈ {a_1 | f a.1 ≤ a_1} ∩ {a_1 | a_1 < g a.1}})

tactic: refine
  MeasurableSet.inter ?_
    ((measurableSet_le (hf.comp measurable_fst) measurable_snd).inter
      (measurableSet_lt measurable_snd (hg.comp measurable_fst)))
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
f g : α → ℝ
s : Set α
hf : Measurable f
hg : Measurable g
hs : MeasurableSet s
⊢ MeasurableSet ({a | a.1 ∈ s} ∩ {a | a.2 ∈ {a_1 | f a.1 ≤ a_1} ∩ {a_1 | a_1 < g a.1}})
state_after: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
f g : α → ℝ
s : Set α
hf : Measurable f
hg : Measurable g
hs : MeasurableSet s
⊢ MeasurableSet {a | a.1 ∈ s}

tactic: exact measurable_fst hs
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : Measure α
f g : α → ℝ
s : Set α
hf : Measurable f
hg : Measurable g
hs : MeasurableSet s
⊢ MeasurableSet {a | a.1 ∈ s}
state_after: no goals
Theorem: AddLECancellable.tsub_add_eq_add_tsub
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: rw [add_comm a, hb.add_tsub_assoc_of_le h, add_comm]
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hb : AddLECancellable b
h : b ≤ a
⊢ a - b + c = a + c - b
state_after: no goals
Theorem: Filter.eq_top_of_neBot
File: Mathlib/Order/Filter/Basic.lean

tactic: refine top_unique fun s hs => ?_
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s t : Set α
inst✝¹ : Subsingleton α
l : Filter α
inst✝ : l.NeBot
⊢ l = ⊤
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t : Set α
inst✝¹ : Subsingleton α
l : Filter α
inst✝ : l.NeBot
s : Set α
hs : s ∈ l
⊢ s ∈ ⊤

tactic: obtain rfl : s = univ := Subsingleton.eq_univ_of_nonempty (nonempty_of_mem hs)
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t : Set α
inst✝¹ : Subsingleton α
l : Filter α
inst✝ : l.NeBot
s : Set α
hs : s ∈ l
⊢ s ∈ ⊤
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s t : Set α
inst✝¹ : Subsingleton α
l : Filter α
inst✝ : l.NeBot
hs : univ ∈ l
⊢ univ ∈ ⊤

tactic: exact univ_mem
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s t : Set α
inst✝¹ : Subsingleton α
l : Filter α
inst✝ : l.NeBot
hs : univ ∈ l
⊢ univ ∈ ⊤
state_after: no goals
Theorem: Pell.y_mul_dvd
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: rw [Nat.mul_succ, yn_add]
state_before: a : ℕ
a1 : 1 < a
n k : ℕ
⊢ yn a1 n ∣ yn a1 (n * (k + 1))
state_after: a : ℕ
a1 : 1 < a
n k : ℕ
⊢ yn a1 n ∣ xn a1 (n * k) * yn a1 n + yn a1 (n * k) * xn a1 n

tactic: exact dvd_add (dvd_mul_left _ _) ((y_mul_dvd _ k).mul_right _)
state_before: a : ℕ
a1 : 1 < a
n k : ℕ
⊢ yn a1 n ∣ xn a1 (n * k) * yn a1 n + yn a1 (n * k) * xn a1 n
state_after: no goals
Theorem: RatFunc.mk_zero
File: Mathlib/FieldTheory/RatFunc/Defs.lean

tactic: rw [mk_eq_div', RingHom.map_zero, div_zero]
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
p : K[X]
⊢ RatFunc.mk p 0 = { toFractionRing := 0 }
state_after: no goals
Theorem: LinearMap.iterate_surjective
File: Mathlib/Algebra/Module/LinearMap/End.lean

tactic: rw [iterate_succ]
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
S : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
N : Type u_9
N₁ : Type u_10
N₂ : Type u_11
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommGroup N₁
inst✝⁴ : Module R M
inst✝³ : Module R N₁
inst✝² : Monoid S
inst✝¹ : DistribMulAction S M
inst✝ : SMulCommClass R S M
f' : M →ₗ[R] M
h : Surjective ⇑f'
n : ℕ
⊢ Surjective ⇑(f' ^ (n + 1))
state_after: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
S : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
N : Type u_9
N₁ : Type u_10
N₂ : Type u_11
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommGroup N₁
inst✝⁴ : Module R M
inst✝³ : Module R N₁
inst✝² : Monoid S
inst✝¹ : DistribMulAction S M
inst✝ : SMulCommClass R S M
f' : M →ₗ[R] M
h : Surjective ⇑f'
n : ℕ
⊢ Surjective ⇑((f' ^ n) ∘ₗ f')

tactic: exact (iterate_surjective h n).comp h
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
S : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
N : Type u_9
N₁ : Type u_10
N₂ : Type u_11
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommGroup N₁
inst✝⁴ : Module R M
inst✝³ : Module R N₁
inst✝² : Monoid S
inst✝¹ : DistribMulAction S M
inst✝ : SMulCommClass R S M
f' : M →ₗ[R] M
h : Surjective ⇑f'
n : ℕ
⊢ Surjective ⇑((f' ^ n) ∘ₗ f')
state_after: no goals
Theorem: GaloisConnection.upperBounds_l_image
File: Mathlib/Order/GaloisConnection.lean

tactic: simp [upperBounds, gc _ _]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort u_1
a a₁ a₂ : α
b✝ b₁ b₂ : β
inst✝¹ : Preorder α
inst✝ : Preorder β
l : α → β
u : β → α
gc : GaloisConnection l u
s : Set α
b : β
⊢ b ∈ upperBounds (l '' s) ↔ b ∈ u ⁻¹' upperBounds s
state_after: no goals
Theorem: MeasureTheory.hasFiniteIntegral_iff_ofNNReal
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp [hasFiniteIntegral_iff_norm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ≥0
⊢ HasFiniteIntegral (fun x => ↑(f x)) μ ↔ ∫⁻ (a : α), ↑(f a) ∂μ < ⊤
state_after: no goals
Theorem: Complex.I_mul
File: Mathlib/Data/Complex/Basic.lean

tactic: simp
state_before: z : ℂ
⊢ (I * z).re = { re := -z.im, im := z.re }.re ∧ (I * z).im = { re := -z.im, im := z.re }.im
state_after: no goals
Theorem: MvPolynomial.weightedHomogeneousComponent_mem
File: Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean

tactic: rw [mem_weightedHomogeneousSubmodule]
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
w✝ : σ → M
n : M
φ✝ ψ : MvPolynomial σ R
w : σ → M
φ : MvPolynomial σ R
m : M
⊢ (weightedHomogeneousComponent w m) φ ∈ weightedHomogeneousSubmodule R w m
state_after: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
w✝ : σ → M
n : M
φ✝ ψ : MvPolynomial σ R
w : σ → M
φ : MvPolynomial σ R
m : M
⊢ IsWeightedHomogeneous w ((weightedHomogeneousComponent w m) φ) m

tactic: exact weightedHomogeneousComponent_isWeightedHomogeneous m φ
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
w✝ : σ → M
n : M
φ✝ ψ : MvPolynomial σ R
w : σ → M
φ : MvPolynomial σ R
m : M
⊢ IsWeightedHomogeneous w ((weightedHomogeneousComponent w m) φ) m
state_after: no goals
Theorem: List.fst_lt_add_of_mem_enumFrom
File: Mathlib/Data/List/Enum.lean

tactic: rcases mem_iff_get.1 h with ⟨i, rfl⟩
state_before: α : Type u_1
β : Type u_2
x : ℕ × α
n : ℕ
l : List α
h : x ∈ enumFrom n l
⊢ x.1 < n + l.length
state_after: case intro
α : Type u_1
β : Type u_2
n : ℕ
l : List α
i : Fin (enumFrom n l).length
h : (enumFrom n l).get i ∈ enumFrom n l
⊢ ((enumFrom n l).get i).1 < n + l.length

tactic: simpa using i.is_lt
state_before: case intro
α : Type u_1
β : Type u_2
n : ℕ
l : List α
i : Fin (enumFrom n l).length
h : (enumFrom n l).get i ∈ enumFrom n l
⊢ ((enumFrom n l).get i).1 < n + l.length
state_after: no goals
Theorem: CauSeq.Completion.ofRat_div
File: Mathlib/Algebra/Order/CauSeq/Completion.lean

tactic: simp only [div_eq_mul_inv, ofRat_inv, ofRat_mul]
state_before: α : Type u_1
inst✝² : LinearOrderedField α
β : Type u_2
inst✝¹ : DivisionRing β
abv : β → α
inst✝ : IsAbsoluteValue abv
x y : β
⊢ ofRat (x / y) = ofRat x / ofRat y
state_after: no goals
Theorem: Filter.tendsto_nhds
File: Mathlib/Topology/Filter.lean

tactic: simp only [nhds_eq', tendsto_lift', mem_setOf_eq]
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
X : Type u_4
Y : Type u_5
la : Filter α
lb : Filter β
f : α → Filter β
⊢ Tendsto f la (𝓝 lb) ↔ ∀ s ∈ lb, ∀ᶠ (a : α) in la, s ∈ f a
state_after: no goals
Theorem: Finpartition.card_parts_equitabilise
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Equitabilise.lean

tactic: rw [← filter_true_of_mem fun x => card_eq_of_mem_parts_equitabilise, filter_or,
  card_union_of_disjoint, P.card_filter_equitabilise_small _ hm, P.card_filter_equitabilise_big]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
m n a b : ℕ
P : Finpartition s
h : a * m + b * (m + 1) = s.card
hm : m ≠ 0
⊢ (equitabilise h).parts.card = a + b
state_after: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
m n a b : ℕ
P : Finpartition s
h : a * m + b * (m + 1) = s.card
hm : m ≠ 0
⊢ Disjoint (filter (fun x => x.card = m) (equitabilise h).parts)
    (filter (fun x => x.card = m + 1) (equitabilise h).parts)

tactic: exact disjoint_filter.2 fun x _ h₀ h₁ => Nat.succ_ne_self m <| h₁.symm.trans h₀
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
m n a b : ℕ
P : Finpartition s
h : a * m + b * (m + 1) = s.card
hm : m ≠ 0
⊢ Disjoint (filter (fun x => x.card = m) (equitabilise h).parts)
    (filter (fun x => x.card = m + 1) (equitabilise h).parts)
state_after: no goals
Theorem: Nat.set_eq_univ
File: Mathlib/Data/Nat/Order/Lemmas.lean

tactic: rintro rfl
state_before: a b m n k : ℕ
S : Set ℕ
⊢ S = Set.univ → 0 ∈ S ∧ ∀ k ∈ S, k + 1 ∈ S
state_after: a b m n k : ℕ
⊢ 0 ∈ Set.univ ∧ ∀ k ∈ Set.univ, k + 1 ∈ Set.univ

tactic: simp
state_before: a b m n k : ℕ
⊢ 0 ∈ Set.univ ∧ ∀ k ∈ Set.univ, k + 1 ∈ Set.univ
state_after: no goals
Theorem: ProbabilityTheory.measurable_condexpKernel
File: Mathlib/Probability/Kernel/Condexp.lean

tactic: simp_rw [condexpKernel_apply_eq_condDistrib]
state_before: Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
μ : Measure Ω
inst✝¹ : IsFiniteMeasure μ
inst✝ : NormedAddCommGroup F
f : Ω → F
s : Set Ω
hs : MeasurableSet s
⊢ Measurable fun ω => ((condexpKernel μ m) ω) s
state_after: Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
μ : Measure Ω
inst✝¹ : IsFiniteMeasure μ
inst✝ : NormedAddCommGroup F
f : Ω → F
s : Set Ω
hs : MeasurableSet s
⊢ Measurable fun ω => ((condDistrib id id μ) (id ω)) s

tactic: convert measurable_condDistrib (μ := μ) hs
state_before: Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
μ : Measure Ω
inst✝¹ : IsFiniteMeasure μ
inst✝ : NormedAddCommGroup F
f : Ω → F
s : Set Ω
hs : MeasurableSet s
⊢ Measurable fun ω => ((condDistrib id id μ) (id ω)) s
state_after: case h.e'_3
Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
μ : Measure Ω
inst✝¹ : IsFiniteMeasure μ
inst✝ : NormedAddCommGroup F
f : Ω → F
s : Set Ω
hs : MeasurableSet s
⊢ m ⊓ mΩ = MeasurableSpace.comap id (m ⊓ mΩ)

tactic: rw [MeasurableSpace.comap_id]
state_before: case h.e'_3
Ω : Type u_1
F : Type u_2
m mΩ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
μ : Measure Ω
inst✝¹ : IsFiniteMeasure μ
inst✝ : NormedAddCommGroup F
f : Ω → F
s : Set Ω
hs : MeasurableSet s
⊢ m ⊓ mΩ = MeasurableSpace.comap id (m ⊓ mΩ)
state_after: no goals
Theorem: CategoryTheory.SimplicialObject.δ_comp_δ_self
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: dsimp [δ]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
⊢ X.δ i.castSucc ≫ X.δ i = X.δ i.succ ≫ X.δ i
state_after: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
⊢ X.map (SimplexCategory.δ i.castSucc).op ≫ X.map (SimplexCategory.δ i).op =
    X.map (SimplexCategory.δ i.succ).op ≫ X.map (SimplexCategory.δ i).op

tactic: simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_δ_self]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
⊢ X.map (SimplexCategory.δ i.castSucc).op ≫ X.map (SimplexCategory.δ i).op =
    X.map (SimplexCategory.δ i.succ).op ≫ X.map (SimplexCategory.δ i).op
state_after: no goals
Theorem: Ordinal.Cardinal.mk_iUnion_Ordinal_le_of_le
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: simp_rw [← mem_Iio, biUnion_eq_iUnion, iUnion, iSup, ← o.enumIsoOut.symm.surjective.range_comp]
state_before: β : Type u_1
o : Ordinal.{u_1}
c : Cardinal.{u_1}
ho : o.card ≤ c
hc : ℵ₀ ≤ c
A : Ordinal.{u_1} → Set β
hA : ∀ j < o, #↑(A j) ≤ c
⊢ #↑(⋃ j, ⋃ (_ : j < o), A j) ≤ c
state_after: β : Type u_1
o : Ordinal.{u_1}
c : Cardinal.{u_1}
ho : o.card ≤ c
hc : ℵ₀ ≤ c
A : Ordinal.{u_1} → Set β
hA : ∀ j < o, #↑(A j) ≤ c
⊢ #↑(sSup (range ((fun x => A ↑x) ∘ ⇑o.enumIsoOut.symm))) ≤ c

tactic: apply ((mk_iUnion_le _).trans _).trans_eq (mul_eq_self hc)
state_before: β : Type u_1
o : Ordinal.{u_1}
c : Cardinal.{u_1}
ho : o.card ≤ c
hc : ℵ₀ ≤ c
A : Ordinal.{u_1} → Set β
hA : ∀ j < o, #↑(A j) ≤ c
⊢ #↑(sSup (range ((fun x => A ↑x) ∘ ⇑o.enumIsoOut.symm))) ≤ c
state_after: β : Type u_1
o : Ordinal.{u_1}
c : Cardinal.{u_1}
ho : o.card ≤ c
hc : ℵ₀ ≤ c
A : Ordinal.{u_1} → Set β
hA : ∀ j < o, #↑(A j) ≤ c
⊢ #(Quotient.out o).α * ⨆ i, #↑(((fun x => A ↑x) ∘ ⇑o.enumIsoOut.symm) i) ≤ c * c

tactic: rw [mk_ordinal_out]
state_before: β : Type u_1
o : Ordinal.{u_1}
c : Cardinal.{u_1}
ho : o.card ≤ c
hc : ℵ₀ ≤ c
A : Ordinal.{u_1} → Set β
hA : ∀ j < o, #↑(A j) ≤ c
⊢ #(Quotient.out o).α * ⨆ i, #↑(((fun x => A ↑x) ∘ ⇑o.enumIsoOut.symm) i) ≤ c * c
state_after: β : Type u_1
o : Ordinal.{u_1}
c : Cardinal.{u_1}
ho : o.card ≤ c
hc : ℵ₀ ≤ c
A : Ordinal.{u_1} → Set β
hA : ∀ j < o, #↑(A j) ≤ c
⊢ o.card * ⨆ i, #↑(((fun x => A ↑x) ∘ ⇑o.enumIsoOut.symm) i) ≤ c * c
Theorem: Function.mulSupport_disjoint_iff
File: Mathlib/Algebra/Group/Support.lean

tactic: simp_rw [← subset_compl_iff_disjoint_right, mulSupport_subset_iff', not_mem_compl_iff, EqOn,
  Pi.one_apply]
state_before: α : Type u_1
β : Type u_2
A : Type u_3
B : Type u_4
M : Type u_5
N : Type u_6
P : Type u_7
G : Type u_8
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : α → M
s : Set α
⊢ Disjoint (mulSupport f) s ↔ EqOn f 1 s
state_after: no goals
Theorem: BooleanRing.sup_assoc
File: Mathlib/Algebra/Ring/BooleanRing.lean

tactic: ring
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : BooleanRing α
inst✝¹ : BooleanRing β
inst✝ : BooleanRing γ
a b c : α
⊢ a + b + a * b + c + (a + b + a * b) * c = a + (b + c + b * c) + a * (b + c + b * c)
state_after: no goals
Theorem: affinity_unitClosedBall
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: rw [smul_closedUnitBall, Real.norm_of_nonneg hr, vadd_closedBall_zero]
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
r : ℝ
hr : 0 ≤ r
x : E
⊢ x +ᵥ r • closedBall 0 1 = closedBall x r
state_after: no goals
Theorem: inv_mul_eq_iff_eq_mul
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [← h, mul_inv_cancel_left]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : a⁻¹ * b = c
⊢ b = a * c
state_after: no goals

tactic: rw [h, inv_mul_cancel_left]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : b = a * c
⊢ a⁻¹ * b = c
state_after: no goals
Theorem: ciSup_eq_ite
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: by_cases H : p <;> simp [ciSup_neg, H]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : ConditionallyCompleteLattice α
s t : Set α
a b : α
p : Prop
inst✝ : Decidable p
f : p → α
⊢ ⨆ (h : p), f h = if h : p then f h else sSup ∅
state_after: no goals
Theorem: Relation.iff_comp
File: Mathlib/Logic/Relation.lean

tactic: rw [this, eq_comp]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r✝ : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
r : Prop → α → Prop
this : (fun x x_1 => x ↔ x_1) = fun x x_1 => x = x_1
⊢ (fun x x_1 => x ↔ x_1) ∘r r = r
state_after: no goals

tactic: funext a b
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r✝ : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
r : Prop → α → Prop
⊢ (fun x x_1 => x ↔ x_1) = fun x x_1 => x = x_1
state_after: case h.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r✝ : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
r : Prop → α → Prop
a b : Prop
⊢ (a ↔ b) = (a = b)

tactic: exact iff_eq_eq
state_before: case h.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r✝ : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
r : Prop → α → Prop
a b : Prop
⊢ (a ↔ b) = (a = b)
state_after: no goals
Theorem: Part.bind_map
File: Mathlib/Data/Part.lean

tactic: rw [← bind_some_eq_map, bind_assoc]
state_before: α : Type u_1
β : Type u_2
γ✝ : Type u_3
γ : Type u_4
f : α → β
x : Part α
g : β → Part γ
⊢ (map f x).bind g = x.bind fun y => g (f y)
state_after: α : Type u_1
β : Type u_2
γ✝ : Type u_3
γ : Type u_4
f : α → β
x : Part α
g : β → Part γ
⊢ (x.bind fun x => ((some ∘ f) x).bind g) = x.bind fun y => g (f y)

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ✝ : Type u_3
γ : Type u_4
f : α → β
x : Part α
g : β → Part γ
⊢ (x.bind fun x => ((some ∘ f) x).bind g) = x.bind fun y => g (f y)
state_after: no goals
Theorem: Polynomial.bernoulli_three_eval_one_quarter
File: Mathlib/NumberTheory/ZetaValues.lean

tactic: simp_rw [Polynomial.bernoulli, Finset.sum_range_succ, Polynomial.eval_add,
  Polynomial.eval_monomial]
state_before: ⊢ eval (1 / 4) (bernoulli 3) = 3 / 64
state_after: ⊢ eval (1 / 4) (∑ i ∈ Finset.range 0, (monomial (3 - i)) (_root_.bernoulli i * ↑(Nat.choose 3 i))) +
            _root_.bernoulli 0 * ↑(Nat.choose 3 0) * (1 / 4) ^ (3 - 0) +
          _root_.bernoulli 1 * ↑(Nat.choose 3 1) * (1 / 4) ^ (3 - 1) +
        _root_.bernoulli 2 * ↑(Nat.choose 3 2) * (1 / 4) ^ (3 - 2) +
      _root_.bernoulli 3 * ↑(Nat.choose 3 3) * (1 / 4) ^ (3 - 3) =
    3 / 64

tactic: rw [Finset.sum_range_zero, Polynomial.eval_zero, zero_add, bernoulli_one]
state_before: ⊢ eval (1 / 4) (∑ i ∈ Finset.range 0, (monomial (3 - i)) (_root_.bernoulli i * ↑(Nat.choose 3 i))) +
            _root_.bernoulli 0 * ↑(Nat.choose 3 0) * (1 / 4) ^ (3 - 0) +
          _root_.bernoulli 1 * ↑(Nat.choose 3 1) * (1 / 4) ^ (3 - 1) +
        _root_.bernoulli 2 * ↑(Nat.choose 3 2) * (1 / 4) ^ (3 - 2) +
      _root_.bernoulli 3 * ↑(Nat.choose 3 3) * (1 / 4) ^ (3 - 3) =
    3 / 64
state_after: ⊢ _root_.bernoulli 0 * ↑(Nat.choose 3 0) * (1 / 4) ^ (3 - 0) + -1 / 2 * ↑(Nat.choose 3 1) * (1 / 4) ^ (3 - 1) +
        _root_.bernoulli 2 * ↑(Nat.choose 3 2) * (1 / 4) ^ (3 - 2) +
      _root_.bernoulli 3 * ↑(Nat.choose 3 3) * (1 / 4) ^ (3 - 3) =
    3 / 64

tactic: rw [bernoulli_eq_bernoulli'_of_ne_one zero_ne_one, bernoulli'_zero,
  bernoulli_eq_bernoulli'_of_ne_one (by decide : 2 ≠ 1), bernoulli'_two,
  bernoulli_eq_bernoulli'_of_ne_one (by decide : 3 ≠ 1), bernoulli'_three]
state_before: ⊢ _root_.bernoulli 0 * ↑(Nat.choose 3 0) * (1 / 4) ^ (3 - 0) + -1 / 2 * ↑(Nat.choose 3 1) * (1 / 4) ^ (3 - 1) +
        _root_.bernoulli 2 * ↑(Nat.choose 3 2) * (1 / 4) ^ (3 - 2) +
      _root_.bernoulli 3 * ↑(Nat.choose 3 3) * (1 / 4) ^ (3 - 3) =
    3 / 64
state_after: ⊢ 1 * ↑(Nat.choose 3 0) * (1 / 4) ^ (3 - 0) + -1 / 2 * ↑(Nat.choose 3 1) * (1 / 4) ^ (3 - 1) +
        1 / 6 * ↑(Nat.choose 3 2) * (1 / 4) ^ (3 - 2) +
      0 * ↑(Nat.choose 3 3) * (1 / 4) ^ (3 - 3) =
    3 / 64

tactic: norm_num
state_before: ⊢ 1 * ↑(Nat.choose 3 0) * (1 / 4) ^ (3 - 0) + -1 / 2 * ↑(Nat.choose 3 1) * (1 / 4) ^ (3 - 1) +
        1 / 6 * ↑(Nat.choose 3 2) * (1 / 4) ^ (3 - 2) +
      0 * ↑(Nat.choose 3 3) * (1 / 4) ^ (3 - 3) =
    3 / 64
state_after: no goals

tactic: decide
state_before: ⊢ 2 ≠ 1
state_after: no goals

tactic: decide
state_before: ⊢ 3 ≠ 1
state_after: no goals
Theorem: finSuccEquiv'_last_apply_castSucc
File: Mathlib/Logic/Equiv/Fin.lean

tactic: rw [← Fin.succAbove_last, finSuccEquiv'_succAbove]
state_before: m n : ℕ
i : Fin n
⊢ (finSuccEquiv' (Fin.last n)) i.castSucc = some i
state_after: no goals
Theorem: RatFunc.liftMonoidWithZeroHom_apply_div
File: Mathlib/FieldTheory/RatFunc/Basic.lean

tactic: rcases eq_or_ne q 0 with (rfl | hq)
state_before: K : Type u
inst✝² : CommRing K
inst✝¹ : IsDomain K
L : Type u_1
inst✝ : CommGroupWithZero L
φ : K[X] →*₀ L
hφ : K[X]⁰ ≤ Submonoid.comap φ L⁰
p q : K[X]
⊢ (liftMonoidWithZeroHom φ hφ) ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q) = φ p / φ q
state_after: case inl
K : Type u
inst✝² : CommRing K
inst✝¹ : IsDomain K
L : Type u_1
inst✝ : CommGroupWithZero L
φ : K[X] →*₀ L
hφ : K[X]⁰ ≤ Submonoid.comap φ L⁰
p : K[X]
⊢ (liftMonoidWithZeroHom φ hφ) ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) 0) = φ p / φ 0

case inr
K : Type u
inst✝² : CommRing K
inst✝¹ : IsDomain K
L : Type u_1
inst✝ : CommGroupWithZero L
φ : K[X] →*₀ L
hφ : K[X]⁰ ≤ Submonoid.comap φ L⁰
p q : K[X]
hq : q ≠ 0
⊢ (liftMonoidWithZeroHom φ hφ) ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q) = φ p / φ q

tactic: simp only [← mk_eq_div, mk_eq_localization_mk _ hq,
  liftMonoidWithZeroHom_apply_ofFractionRing_mk]
state_before: case inr
K : Type u
inst✝² : CommRing K
inst✝¹ : IsDomain K
L : Type u_1
inst✝ : CommGroupWithZero L
φ : K[X] →*₀ L
hφ : K[X]⁰ ≤ Submonoid.comap φ L⁰
p q : K[X]
hq : q ≠ 0
⊢ (liftMonoidWithZeroHom φ hφ) ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q) = φ p / φ q
state_after: no goals

tactic: simp only [div_zero, map_zero]
state_before: case inl
K : Type u
inst✝² : CommRing K
inst✝¹ : IsDomain K
L : Type u_1
inst✝ : CommGroupWithZero L
φ : K[X] →*₀ L
hφ : K[X]⁰ ≤ Submonoid.comap φ L⁰
p : K[X]
⊢ (liftMonoidWithZeroHom φ hφ) ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) 0) = φ p / φ 0
state_after: no goals
Theorem: mul_self_inj_of_nonneg
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: subst a
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
a0 : 0 ≤ a
b0 : 0 ≤ b
h : a = -b
⊢ a = b
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
b c d : α
n : ℤ
b0 : 0 ≤ b
a0 : 0 ≤ -b
⊢ -b = b

tactic: have : b = 0 := le_antisymm (neg_nonneg.1 a0) b0
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
b c d : α
n : ℤ
b0 : 0 ≤ b
a0 : 0 ≤ -b
⊢ -b = b
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
b c d : α
n : ℤ
b0 : 0 ≤ b
a0 : 0 ≤ -b
this : b = 0
⊢ -b = b

tactic: rw [this, neg_zero]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
b c d : α
n : ℤ
b0 : 0 ≤ b
a0 : 0 ≤ -b
this : b = 0
⊢ -b = b
state_after: no goals
Theorem: Filter.Tendsto.prod_atBot
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: rw [← prod_atBot_atBot_eq]
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf γ
f g : α → γ
hf : Tendsto f atBot atBot
hg : Tendsto g atBot atBot
⊢ Tendsto (Prod.map f g) atBot atBot
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf γ
f g : α → γ
hf : Tendsto f atBot atBot
hg : Tendsto g atBot atBot
⊢ Tendsto (Prod.map f g) (atBot ×ˢ atBot) atBot

tactic: exact hf.prod_map_prod_atBot hg
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf γ
f g : α → γ
hf : Tendsto f atBot atBot
hg : Tendsto g atBot atBot
⊢ Tendsto (Prod.map f g) (atBot ×ˢ atBot) atBot
state_after: no goals