1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Finset.sum_range_succ_mul_sum_range_succ
File: Mathlib/Algebra/BigOperators/Ring.lean

tactic: simp only [add_mul, mul_add, add_assoc, sum_range_succ]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
s s₁ s₂ : Finset ι
i : ι
a : α
f✝ g✝ : ι → α
inst✝ : NonUnitalNonAssocSemiring α
m n : ℕ
f g : ℕ → α
⊢ (∑ i ∈ range (m + 1), f i) * ∑ i ∈ range (n + 1), g i =
    (∑ i ∈ range m, f i) * ∑ i ∈ range n, g i + f m * ∑ i ∈ range n, g i + (∑ i ∈ range m, f i) * g n + f m * g n
state_after: no goals
Theorem: ProbabilityTheory.kernel.comp_assoc
File: Mathlib/Probability/Kernel/Composition.lean

tactic: refine ext_fun fun a f hf => ?_
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
δ : Type u_5
mδ : MeasurableSpace δ
ξ : ↥(kernel γ δ)
inst✝ : IsSFiniteKernel ξ
η : ↥(kernel β γ)
κ : ↥(kernel α β)
⊢ ξ ∘ₖ η ∘ₖ κ = ξ ∘ₖ (η ∘ₖ κ)
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f✝ : β → γ
g : γ → α
δ : Type u_5
mδ : MeasurableSpace δ
ξ : ↥(kernel γ δ)
inst✝ : IsSFiniteKernel ξ
η : ↥(kernel β γ)
κ : ↥(kernel α β)
a : α
f : δ → ℝ≥0∞
hf : Measurable f
⊢ ∫⁻ (b : δ), f b ∂(ξ ∘ₖ η ∘ₖ κ) a = ∫⁻ (b : δ), f b ∂(ξ ∘ₖ (η ∘ₖ κ)) a

tactic: simp_rw [lintegral_comp _ _ _ hf, lintegral_comp _ _ _ hf.lintegral_kernel]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f✝ : β → γ
g : γ → α
δ : Type u_5
mδ : MeasurableSpace δ
ξ : ↥(kernel γ δ)
inst✝ : IsSFiniteKernel ξ
η : ↥(kernel β γ)
κ : ↥(kernel α β)
a : α
f : δ → ℝ≥0∞
hf : Measurable f
⊢ ∫⁻ (b : δ), f b ∂(ξ ∘ₖ η ∘ₖ κ) a = ∫⁻ (b : δ), f b ∂(ξ ∘ₖ (η ∘ₖ κ)) a
state_after: no goals
Theorem: SimpleGraph.nonempty_of_pos_dist
File: Mathlib/Combinatorics/SimpleGraph/Metric.lean

tactic: simpa [Set.range_nonempty_iff_nonempty, Set.nonempty_iff_univ_nonempty] using
  Nat.nonempty_of_pos_sInf h
state_before: V : Type u_1
G : SimpleGraph V
u v : V
h : 0 < G.dist u v
⊢ Set.univ.Nonempty
state_after: no goals
Theorem: Function.Embedding.toEquivRange_eq_ofInjective
File: Mathlib/Logic/Equiv/Fintype.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : DecidableEq β
e : Equiv.Perm α
f : α ↪ β
⊢ f.toEquivRange = Equiv.ofInjective ⇑f ⋯
state_after: case H.a
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : DecidableEq β
e : Equiv.Perm α
f : α ↪ β
x✝ : α
⊢ ↑(f.toEquivRange x✝) = ↑((Equiv.ofInjective ⇑f ⋯) x✝)

tactic: simp
state_before: case H.a
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : DecidableEq β
e : Equiv.Perm α
f : α ↪ β
x✝ : α
⊢ ↑(f.toEquivRange x✝) = ↑((Equiv.ofInjective ⇑f ⋯) x✝)
state_after: no goals
Theorem: List.doubleton_eq
File: Mathlib/Data/List/Basic.lean

tactic: rw [insert_neg, singleton_eq]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : DecidableEq α
x y : α
h : x ≠ y
⊢ {x, y} = [x, y]
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : DecidableEq α
x y : α
h : x ≠ y
⊢ ¬x ∈ {y}

tactic: rwa [singleton_eq, mem_singleton]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : DecidableEq α
x y : α
h : x ≠ y
⊢ ¬x ∈ {y}
state_after: no goals
Theorem: Ideal.comap_bot_le_of_injective
File: Mathlib/RingTheory/Ideal/Maps.lean

tactic: refine le_trans (fun x hx => ?_) bot_le
state_before: R : Type u
S : Type v
F : Type u_1
inst✝³ : Semiring R
inst✝² : Semiring S
inst✝¹ : FunLike F R S
rc : RingHomClass F R S
f : F
I J : Ideal R
K L : Ideal S
G : Type u_2
inst✝ : FunLike G S R
rcg : RingHomClass G S R
ι : Sort u_3
hf : Function.Injective ⇑f
⊢ comap f ⊥ ≤ I
state_after: R : Type u
S : Type v
F : Type u_1
inst✝³ : Semiring R
inst✝² : Semiring S
inst✝¹ : FunLike F R S
rc : RingHomClass F R S
f : F
I J : Ideal R
K L : Ideal S
G : Type u_2
inst✝ : FunLike G S R
rcg : RingHomClass G S R
ι : Sort u_3
hf : Function.Injective ⇑f
x : R
hx : x ∈ comap f ⊥
⊢ x ∈ ⊥

tactic: rw [mem_comap, Submodule.mem_bot, ← map_zero f] at hx
state_before: R : Type u
S : Type v
F : Type u_1
inst✝³ : Semiring R
inst✝² : Semiring S
inst✝¹ : FunLike F R S
rc : RingHomClass F R S
f : F
I J : Ideal R
K L : Ideal S
G : Type u_2
inst✝ : FunLike G S R
rcg : RingHomClass G S R
ι : Sort u_3
hf : Function.Injective ⇑f
x : R
hx : x ∈ comap f ⊥
⊢ x ∈ ⊥
state_after: R : Type u
S : Type v
F : Type u_1
inst✝³ : Semiring R
inst✝² : Semiring S
inst✝¹ : FunLike F R S
rc : RingHomClass F R S
f : F
I J : Ideal R
K L : Ideal S
G : Type u_2
inst✝ : FunLike G S R
rcg : RingHomClass G S R
ι : Sort u_3
hf : Function.Injective ⇑f
x : R
hx : f x = f 0
⊢ x ∈ ⊥

tactic: exact Eq.symm (hf hx) ▸ Submodule.zero_mem ⊥
state_before: R : Type u
S : Type v
F : Type u_1
inst✝³ : Semiring R
inst✝² : Semiring S
inst✝¹ : FunLike F R S
rc : RingHomClass F R S
f : F
I J : Ideal R
K L : Ideal S
G : Type u_2
inst✝ : FunLike G S R
rcg : RingHomClass G S R
ι : Sort u_3
hf : Function.Injective ⇑f
x : R
hx : f x = f 0
⊢ x ∈ ⊥
state_after: no goals
Theorem: MeasureTheory.Measure.dirac_one_mconv
File: Mathlib/MeasureTheory/Group/Convolution.lean

tactic: unfold mconv
state_before: M : Type u_1
inst✝³ : Monoid M
inst✝² : MeasurableSpace M
inst✝¹ : MeasurableMul₂ M
μ : Measure M
inst✝ : SFinite μ
⊢ dirac 1 ∗ μ = μ
state_after: M : Type u_1
inst✝³ : Monoid M
inst✝² : MeasurableSpace M
inst✝¹ : MeasurableMul₂ M
μ : Measure M
inst✝ : SFinite μ
⊢ map (fun x => x.1 * x.2) ((dirac 1).prod μ) = μ

tactic: rw [MeasureTheory.Measure.dirac_prod, map_map]
state_before: M : Type u_1
inst✝³ : Monoid M
inst✝² : MeasurableSpace M
inst✝¹ : MeasurableMul₂ M
μ : Measure M
inst✝ : SFinite μ
⊢ map (fun x => x.1 * x.2) ((dirac 1).prod μ) = μ
state_after: M : Type u_1
inst✝³ : Monoid M
inst✝² : MeasurableSpace M
inst✝¹ : MeasurableMul₂ M
μ : Measure M
inst✝ : SFinite μ
⊢ map ((fun x => x.1 * x.2) ∘ Prod.mk 1) μ = μ

case hg
M : Type u_1
inst✝³ : Monoid M
inst✝² : MeasurableSpace M
inst✝¹ : MeasurableMul₂ M
μ : Measure M
inst✝ : SFinite μ
⊢ Measurable fun x => x.1 * x.2

case hf
M : Type u_1
inst✝³ : Monoid M
inst✝² : MeasurableSpace M
inst✝¹ : MeasurableMul₂ M
μ : Measure M
inst✝ : SFinite μ
⊢ Measurable (Prod.mk 1)

tactic: measurability
state_before: case hf
M : Type u_1
inst✝³ : Monoid M
inst✝² : MeasurableSpace M
inst✝¹ : MeasurableMul₂ M
μ : Measure M
inst✝ : SFinite μ
⊢ Measurable (Prod.mk 1)
state_after: no goals

tactic: simp only [Function.comp_def, one_mul, map_id']
state_before: M : Type u_1
inst✝³ : Monoid M
inst✝² : MeasurableSpace M
inst✝¹ : MeasurableMul₂ M
μ : Measure M
inst✝ : SFinite μ
⊢ map ((fun x => x.1 * x.2) ∘ Prod.mk 1) μ = μ
state_after: no goals

tactic: exact Measurable.mul measurable_fst measurable_snd
state_before: case hg
M : Type u_1
inst✝³ : Monoid M
inst✝² : MeasurableSpace M
inst✝¹ : MeasurableMul₂ M
μ : Measure M
inst✝ : SFinite μ
⊢ Measurable fun x => x.1 * x.2
state_after: no goals
Theorem: MeasureTheory.memℒp_const_iff
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

tactic: rw [← snorm_const_lt_top_iff hp_ne_zero hp_ne_top]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
p : ℝ≥0∞
c : E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
⊢ Memℒp (fun x => c) p μ ↔ c = 0 ∨ μ Set.univ < ⊤
state_after: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
p : ℝ≥0∞
c : E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
⊢ Memℒp (fun x => c) p μ ↔ snorm (fun x => c) p μ < ⊤

tactic: exact ⟨fun h => h.2, fun h => ⟨aestronglyMeasurable_const, h⟩⟩
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
p : ℝ≥0∞
c : E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
⊢ Memℒp (fun x => c) p μ ↔ snorm (fun x => c) p μ < ⊤
state_after: no goals
Theorem: CategoryTheory.Limits.Multifork.app_right_eq_ι_comp_fst
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

tactic: rw [← K.w (WalkingMulticospan.Hom.fst b)]
state_before: C : Type u
inst✝ : Category.{v, u} C
I : MulticospanIndex C
K : Multifork I
b : I.R
⊢ K.π.app (WalkingMulticospan.right b) = K.ι (I.fstTo b) ≫ I.fst b
state_after: C : Type u
inst✝ : Category.{v, u} C
I : MulticospanIndex C
K : Multifork I
b : I.R
⊢ K.π.app (WalkingMulticospan.left (I.fstTo b)) ≫ I.multicospan.map (WalkingMulticospan.Hom.fst b) =
    K.ι (I.fstTo b) ≫ I.fst b

tactic: rfl
state_before: C : Type u
inst✝ : Category.{v, u} C
I : MulticospanIndex C
K : Multifork I
b : I.R
⊢ K.π.app (WalkingMulticospan.left (I.fstTo b)) ≫ I.multicospan.map (WalkingMulticospan.Hom.fst b) =
    K.ι (I.fstTo b) ≫ I.fst b
state_after: no goals
Theorem: Real.dist_le_of_mem_uIcc
File: Mathlib/Topology/MetricSpace/Pseudo/Lemmas.lean

tactic: rwa [uIcc_comm]
state_before: ι : Type u_1
α : Type u_2
inst✝ : PseudoMetricSpace α
x y x' y' : ℝ
hx : x ∈ uIcc x' y'
hy : y ∈ uIcc x' y'
⊢ y ∈ uIcc y' x'
state_after: no goals

tactic: rwa [uIcc_comm]
state_before: ι : Type u_1
α : Type u_2
inst✝ : PseudoMetricSpace α
x y x' y' : ℝ
hx : x ∈ uIcc x' y'
hy : y ∈ uIcc x' y'
⊢ x ∈ uIcc y' x'
state_after: no goals
Theorem: List.count_dedup
File: Mathlib/Data/List/Dedup.lean

tactic: simp_rw [count_eq_of_nodup <| nodup_dedup l, mem_dedup]
state_before: α : Type u
inst✝ : DecidableEq α
l : List α
a : α
⊢ count a l.dedup = if a ∈ l then 1 else 0
state_after: no goals
Theorem: Order.not_isPredLimit_iff_exists_covBy
File: Mathlib/Order/SuccPred/Limit.lean

tactic: simp [IsPredLimit]
state_before: α : Type u_1
inst✝ : LT α
a✝ a : α
⊢ ¬IsPredLimit a ↔ ∃ b, a ⋖ b
state_after: no goals
Theorem: RCLike.hasSum_iff
File: Mathlib/Analysis/Complex/Basic.lean

tactic: refine ⟨fun h => ⟨hasSum_re _ h, hasSum_im _ h⟩, ?_⟩
state_before: α : Type u_1
𝕜 : Type u_2
inst✝ : RCLike 𝕜
f : α → 𝕜
c : 𝕜
⊢ HasSum f c ↔ HasSum (fun x => re (f x)) (re c) ∧ HasSum (fun x => im (f x)) (im c)
state_after: α : Type u_1
𝕜 : Type u_2
inst✝ : RCLike 𝕜
f : α → 𝕜
c : 𝕜
⊢ HasSum (fun x => re (f x)) (re c) ∧ HasSum (fun x => im (f x)) (im c) → HasSum f c

tactic: rintro ⟨h₁, h₂⟩
state_before: α : Type u_1
𝕜 : Type u_2
inst✝ : RCLike 𝕜
f : α → 𝕜
c : 𝕜
⊢ HasSum (fun x => re (f x)) (re c) ∧ HasSum (fun x => im (f x)) (im c) → HasSum f c
state_after: case intro
α : Type u_1
𝕜 : Type u_2
inst✝ : RCLike 𝕜
f : α → 𝕜
c : 𝕜
h₁ : HasSum (fun x => re (f x)) (re c)
h₂ : HasSum (fun x => im (f x)) (im c)
⊢ HasSum f c

tactic: simpa only [re_add_im] using
  ((hasSum_ofReal 𝕜).mpr h₁).add (((hasSum_ofReal 𝕜).mpr h₂).mul_right I)
state_before: case intro
α : Type u_1
𝕜 : Type u_2
inst✝ : RCLike 𝕜
f : α → 𝕜
c : 𝕜
h₁ : HasSum (fun x => re (f x)) (re c)
h₂ : HasSum (fun x => im (f x)) (im c)
⊢ HasSum f c
state_after: no goals
Theorem: ProbabilityTheory.iCondIndepFun_iff
File: Mathlib/Probability/Independence/Conditional.lean

tactic: simp only [iCondIndepFun_iff_iCondIndep]
state_before: Ω : Type u_1
ι : Type u_2
m' mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
hm' : m' ≤ mΩ
β : ι → Type u_3
m : (x : ι) → MeasurableSpace (β x)
f : (x : ι) → Ω → β x
hf : ∀ (i : ι), Measurable (f i)
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
⊢ iCondIndepFun m' hm' m f μ ↔
    ∀ (s : Finset ι) {g : ι → Set Ω},
      (∀ i ∈ s, MeasurableSet (g i)) →
        μ[(⋂ i ∈ s, g i).indicator fun ω => 1|m'] =ᶠ[ae μ] ∏ i ∈ s, μ[(g i).indicator fun ω => 1|m']
state_after: Ω : Type u_1
ι : Type u_2
m' mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
hm' : m' ≤ mΩ
β : ι → Type u_3
m : (x : ι) → MeasurableSpace (β x)
f : (x : ι) → Ω → β x
hf : ∀ (i : ι), Measurable (f i)
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
⊢ iCondIndep m' hm' (fun x => MeasurableSpace.comap (f x) (m x)) μ ↔
    ∀ (s : Finset ι) {g : ι → Set Ω},
      (∀ i ∈ s, MeasurableSet (g i)) →
        μ[(⋂ i ∈ s, g i).indicator fun ω => 1|m'] =ᶠ[ae μ] ∏ i ∈ s, μ[(g i).indicator fun ω => 1|m']

tactic: rw [iCondIndep_iff]
state_before: Ω : Type u_1
ι : Type u_2
m' mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
hm' : m' ≤ mΩ
β : ι → Type u_3
m : (x : ι) → MeasurableSpace (β x)
f : (x : ι) → Ω → β x
hf : ∀ (i : ι), Measurable (f i)
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
⊢ iCondIndep m' hm' (fun x => MeasurableSpace.comap (f x) (m x)) μ ↔
    ∀ (s : Finset ι) {g : ι → Set Ω},
      (∀ i ∈ s, MeasurableSet (g i)) →
        μ[(⋂ i ∈ s, g i).indicator fun ω => 1|m'] =ᶠ[ae μ] ∏ i ∈ s, μ[(g i).indicator fun ω => 1|m']
state_after: case hm
Ω : Type u_1
ι : Type u_2
m' mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
hm' : m' ≤ mΩ
β : ι → Type u_3
m : (x : ι) → MeasurableSpace (β x)
f : (x : ι) → Ω → β x
hf : ∀ (i : ι), Measurable (f i)
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
⊢ ∀ (i : ι), MeasurableSpace.comap (f i) (m i) ≤ mΩ

tactic: exact fun i ↦ (hf i).comap_le
state_before: case hm
Ω : Type u_1
ι : Type u_2
m' mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
hm' : m' ≤ mΩ
β : ι → Type u_3
m : (x : ι) → MeasurableSpace (β x)
f : (x : ι) → Ω → β x
hf : ∀ (i : ι), Measurable (f i)
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
⊢ ∀ (i : ι), MeasurableSpace.comap (f i) (m i) ≤ mΩ
state_after: no goals
Theorem: List.nthLe_ofFn
File: Mathlib/Data/List/OfFn.lean

tactic: simp [nthLe]
state_before: α : Type u
n : ℕ
f : Fin n → α
i : Fin n
⊢ (ofFn f).nthLe ↑i ⋯ = f i
state_after: no goals
Theorem: PartENat.ofENat_lt
File: Mathlib/Data/Nat/PartENat.lean

tactic: classical
rw [← toWithTop_lt, toWithTop_ofENat, toWithTop_ofENat]
state_before: x y : ℕ∞
⊢ ↑x < ↑y ↔ x < y
state_after: no goals

tactic: rw [← toWithTop_lt, toWithTop_ofENat, toWithTop_ofENat]
state_before: x y : ℕ∞
⊢ ↑x < ↑y ↔ x < y
state_after: no goals
Theorem: Multiset.mem_product
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp [product, and_left_comm]
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a✝ : α
b✝ : β
s : Multiset α
t : Multiset β
a : α
b : β
⊢ (a, b) ∈ s.product t ↔ (a, b).1 ∈ s ∧ (a, b).2 ∈ t
state_after: no goals
Theorem: div_nonpos_of_nonpos_of_nonneg
File: Mathlib/Algebra/Order/Field/Defs.lean

tactic: rw [div_eq_mul_inv]
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
a b : α
ha : a ≤ 0
hb : 0 ≤ b
⊢ a / b ≤ 0
state_after: α : Type u_1
inst✝ : LinearOrderedSemifield α
a b : α
ha : a ≤ 0
hb : 0 ≤ b
⊢ a * b⁻¹ ≤ 0

tactic: exact mul_nonpos_of_nonpos_of_nonneg ha (inv_nonneg.2 hb)
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
a b : α
ha : a ≤ 0
hb : 0 ≤ b
⊢ a * b⁻¹ ≤ 0
state_after: no goals
Theorem: CompleteLattice.sSup_continuous
File: Mathlib/Order/OmegaCompletePartialOrder.lean

tactic: intro c
state_before: α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
⊢ Continuous (sSup s)
state_after: α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
c : Chain α
⊢ (sSup s) (ωSup c) = ωSup (c.map (sSup s))

tactic: apply eq_of_forall_ge_iff
state_before: α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
c : Chain α
⊢ (sSup s) (ωSup c) = ωSup (c.map (sSup s))
state_after: case H
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
c : Chain α
⊢ ∀ (c_1 : β), (sSup s) (ωSup c) ≤ c_1 ↔ ωSup (c.map (sSup s)) ≤ c_1

tactic: intro z
state_before: case H
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
c : Chain α
⊢ ∀ (c_1 : β), (sSup s) (ωSup c) ≤ c_1 ↔ ωSup (c.map (sSup s)) ≤ c_1
state_after: case H
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
c : Chain α
z : β
⊢ (sSup s) (ωSup c) ≤ z ↔ ωSup (c.map (sSup s)) ≤ z

tactic: suffices (∀ f ∈ s, ∀ (n), (f : _) (c n) ≤ z) ↔ ∀ (n), ∀ f ∈ s, (f : _) (c n) ≤ z by
  simpa (config := { contextual := true }) [ωSup_le_iff, hs _ _ _] using this
state_before: case H
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
c : Chain α
z : β
⊢ (sSup s) (ωSup c) ≤ z ↔ ωSup (c.map (sSup s)) ≤ z
state_after: case H
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
c : Chain α
z : β
⊢ (∀ f ∈ s, ∀ (n : ℕ), f (c n) ≤ z) ↔ ∀ (n : ℕ), ∀ f ∈ s, f (c n) ≤ z

tactic: exact ⟨fun H n f hf => H f hf n, fun H f hf n => H n f hf⟩
state_before: case H
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
c : Chain α
z : β
⊢ (∀ f ∈ s, ∀ (n : ℕ), f (c n) ≤ z) ↔ ∀ (n : ℕ), ∀ f ∈ s, f (c n) ≤ z
state_after: no goals

tactic: simpa (config := { contextual := true }) [ωSup_le_iff, hs _ _ _] using this
state_before: α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
c : Chain α
z : β
this : (∀ f ∈ s, ∀ (n : ℕ), f (c n) ≤ z) ↔ ∀ (n : ℕ), ∀ f ∈ s, f (c n) ≤ z
⊢ (sSup s) (ωSup c) ≤ z ↔ ωSup (c.map (sSup s)) ≤ z
state_after: no goals
Theorem: HasProd.even_mul_odd
File: Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean

tactic: have := mul_right_injective₀ (two_ne_zero' ℕ)
state_before: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℕ → M
he : HasProd (fun k => f (2 * k)) m
ho : HasProd (fun k => f (2 * k + 1)) m'
⊢ HasProd f (m * m')
state_after: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℕ → M
he : HasProd (fun k => f (2 * k)) m
ho : HasProd (fun k => f (2 * k + 1)) m'
this : Injective fun x => 2 * x
⊢ HasProd f (m * m')

tactic: replace ho := ((add_left_injective 1).comp this).hasProd_range_iff.2 ho
state_before: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℕ → M
he : HasProd (fun k => f (2 * k)) m
ho : HasProd (fun k => f (2 * k + 1)) m'
this : Injective fun x => 2 * x
⊢ HasProd f (m * m')
state_after: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℕ → M
he : HasProd (fun k => f (2 * k)) m
this : Injective fun x => 2 * x
ho : HasProd (fun x => f ↑x) m'
⊢ HasProd f (m * m')

tactic: refine (this.hasProd_range_iff.2 he).mul_isCompl ?_ ho
state_before: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℕ → M
he : HasProd (fun k => f (2 * k)) m
this : Injective fun x => 2 * x
ho : HasProd (fun x => f ↑x) m'
⊢ HasProd f (m * m')
state_after: M : Type u_1
inst✝³ : CommMonoid M
inst✝² : TopologicalSpace M
m m' : M
G : Type u_2
inst✝¹ : CommGroup G
g g' : G
inst✝ : ContinuousMul M
f : ℕ → M
he : HasProd (fun k => f (2 * k)) m
this : Injective fun x => 2 * x
ho : HasProd (fun x => f ↑x) m'
⊢ IsCompl (Set.range fun x => 2 * x) (Set.range ((fun x => x + 1) ∘ fun x => 2 * x))
Theorem: Int.preimage_Ici
File: Mathlib/Algebra/Order/Floor.lean

tactic: ext
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ Int.cast ⁻¹' Ici a = Ici ⌈a⌉
state_after: case h
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
x✝ : ℤ
⊢ x✝ ∈ Int.cast ⁻¹' Ici a ↔ x✝ ∈ Ici ⌈a⌉

tactic: simp [ceil_le]
state_before: case h
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
x✝ : ℤ
⊢ x✝ ∈ Int.cast ⁻¹' Ici a ↔ x✝ ∈ Ici ⌈a⌉
state_after: no goals
Theorem: SzemerediRegularity.increment_isEquipartition
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Increment.lean

tactic: simp_rw [IsEquipartition, Set.equitableOn_iff_exists_eq_eq_add_one]
state_before: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : ℝ
⊢ (increment hP G ε).IsEquipartition
state_after: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : ℝ
⊢ ∃ b, ∀ a ∈ ↑(increment hP G ε).parts, a.card = b ∨ a.card = b + 1

tactic: refine ⟨m, fun A hA => ?_⟩
state_before: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : ℝ
⊢ ∃ b, ∀ a ∈ ↑(increment hP G ε).parts, a.card = b ∨ a.card = b + 1
state_after: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : ℝ
A : Finset α
hA : A ∈ ↑(increment hP G ε).parts
⊢ A.card = m ∨ A.card = m + 1

tactic: rw [mem_coe, increment, mem_bind] at hA
state_before: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : ℝ
A : Finset α
hA : A ∈ ↑(increment hP G ε).parts
⊢ A.card = m ∨ A.card = m + 1
state_after: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : ℝ
A : Finset α
hA : ∃ A_1, ∃ (hA : A_1 ∈ P.parts), A ∈ (chunk hP G ε hA).parts
⊢ A.card = m ∨ A.card = m + 1

tactic: obtain ⟨U, hU, hA⟩ := hA
state_before: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : ℝ
A : Finset α
hA : ∃ A_1, ∃ (hA : A_1 ∈ P.parts), A ∈ (chunk hP G ε hA).parts
⊢ A.card = m ∨ A.card = m + 1
state_after: case intro.intro
α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : ℝ
A U : Finset α
hU : U ∈ P.parts
hA : A ∈ (chunk hP G ε hU).parts
⊢ A.card = m ∨ A.card = m + 1

tactic: exact card_eq_of_mem_parts_chunk hA
state_before: case intro.intro
α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : ℝ
A U : Finset α
hU : U ∈ P.parts
hA : A ∈ (chunk hP G ε hU).parts
⊢ A.card = m ∨ A.card = m + 1
state_after: no goals
Theorem: Int.units_ne_iff_eq_neg
File: Mathlib/Algebra/Ring/Int.lean

tactic: simpa only [Ne, Units.ext_iff] using isUnit_ne_iff_eq_neg u.isUnit v.isUnit
state_before: u v : ℤˣ
⊢ u ≠ v ↔ u = -v
state_after: no goals
Theorem: HomologicalComplex₂.D₁_D₂
File: Mathlib/Algebra/Homology/TotalComplex.lean

tactic: simp
state_before: C : Type u_1
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝² : DecidableEq I₁₂
inst✝¹ : TotalComplexShape c₁ c₂ c₁₂
inst✝ : K.HasTotal c₁₂
i₁₂ i₁₂' i₁₂'' : I₁₂
⊢ K.D₁ c₁₂ i₁₂ i₁₂' ≫ K.D₂ c₁₂ i₁₂' i₁₂'' = -K.D₂ c₁₂ i₁₂ i₁₂' ≫ K.D₁ c₁₂ i₁₂' i₁₂''
state_after: no goals
Theorem: Nat.dvd_mul_of_div_dvd
File: Mathlib/Data/Nat/Defs.lean

tactic: obtain ⟨e, rfl⟩ := hdiv
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
h : b ∣ a
hdiv : a / b ∣ c
⊢ a ∣ b * c
state_after: case intro
a b d m n k : ℕ
p q : ℕ → Prop
h : b ∣ a
e : ℕ
⊢ a ∣ b * (a / b * e)

tactic: rw [← Nat.mul_assoc, Nat.mul_comm _ (a / b), Nat.div_mul_cancel h]
state_before: case intro
a b d m n k : ℕ
p q : ℕ → Prop
h : b ∣ a
e : ℕ
⊢ a ∣ b * (a / b * e)
state_after: case intro
a b d m n k : ℕ
p q : ℕ → Prop
h : b ∣ a
e : ℕ
⊢ a ∣ a * e

tactic: exact Nat.dvd_mul_right a e
state_before: case intro
a b d m n k : ℕ
p q : ℕ → Prop
h : b ∣ a
e : ℕ
⊢ a ∣ a * e
state_after: no goals