1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ProbabilityTheory.kernel.tendsto_densityProcess_fst_atTop_ae_of_monotone
File: Mathlib/Probability/Kernel/Disintegration/Density.lean

tactic: filter_upwards [densityProcess_fst_univ_ae κ n a] with x hx
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ✝ : ↥(kernel α (γ × β))
ν : ↥(kernel α γ)
κ : ↥(kernel α (γ × β))
inst✝ : IsFiniteKernel κ
n : ℕ
a : α
seq : ℕ → Set β
hseq : Monotone seq
hseq_iUnion : ⋃ i, seq i = univ
⊢ ∀ᵐ (x : γ) ∂(fst κ) a, Tendsto (fun m => densityProcess κ (fst κ) n a x (seq m)) atTop (𝓝 1)
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ✝ : ↥(kernel α (γ × β))
ν : ↥(kernel α γ)
κ : ↥(kernel α (γ × β))
inst✝ : IsFiniteKernel κ
n : ℕ
a : α
seq : ℕ → Set β
hseq : Monotone seq
hseq_iUnion : ⋃ i, seq i = univ
x : γ
hx : densityProcess κ (fst κ) n a x univ = 1
⊢ Tendsto (fun m => densityProcess κ (fst κ) n a x (seq m)) atTop (𝓝 1)

tactic: rw [← hx]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ✝ : ↥(kernel α (γ × β))
ν : ↥(kernel α γ)
κ : ↥(kernel α (γ × β))
inst✝ : IsFiniteKernel κ
n : ℕ
a : α
seq : ℕ → Set β
hseq : Monotone seq
hseq_iUnion : ⋃ i, seq i = univ
x : γ
hx : densityProcess κ (fst κ) n a x univ = 1
⊢ Tendsto (fun m => densityProcess κ (fst κ) n a x (seq m)) atTop (𝓝 1)
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ✝ : ↥(kernel α (γ × β))
ν : ↥(kernel α γ)
κ : ↥(kernel α (γ × β))
inst✝ : IsFiniteKernel κ
n : ℕ
a : α
seq : ℕ → Set β
hseq : Monotone seq
hseq_iUnion : ⋃ i, seq i = univ
x : γ
hx : densityProcess κ (fst κ) n a x univ = 1
⊢ Tendsto (fun m => densityProcess κ (fst κ) n a x (seq m)) atTop (𝓝 (densityProcess κ (fst κ) n a x univ))

tactic: exact tendsto_densityProcess_fst_atTop_univ_of_monotone κ n a x seq hseq hseq_iUnion
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ✝ : ↥(kernel α (γ × β))
ν : ↥(kernel α γ)
κ : ↥(kernel α (γ × β))
inst✝ : IsFiniteKernel κ
n : ℕ
a : α
seq : ℕ → Set β
hseq : Monotone seq
hseq_iUnion : ⋃ i, seq i = univ
x : γ
hx : densityProcess κ (fst κ) n a x univ = 1
⊢ Tendsto (fun m => densityProcess κ (fst κ) n a x (seq m)) atTop (𝓝 (densityProcess κ (fst κ) n a x univ))
state_after: no goals
Theorem: MvPolynomial.support_X_pow
File: Mathlib/Algebra/MvPolynomial/Basic.lean

tactic: classical
  rw [X_pow_eq_monomial, support_monomial, if_neg (one_ne_zero' R)]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n✝ m : σ
s✝ : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p q : MvPolynomial σ R
inst✝ : Nontrivial R
s : σ
n : ℕ
⊢ (X s ^ n).support = {Finsupp.single s n}
state_after: no goals

tactic: rw [X_pow_eq_monomial, support_monomial, if_neg (one_ne_zero' R)]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n✝ m : σ
s✝ : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p q : MvPolynomial σ R
inst✝ : Nontrivial R
s : σ
n : ℕ
⊢ (X s ^ n).support = {Finsupp.single s n}
state_after: no goals
Theorem: AffineSubspace.affineSpan_pair_parallel_iff_vectorSpan_eq
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: simp [affineSpan_parallel_iff_vectorSpan_eq_and_eq_empty_iff_eq_empty, ←
  not_nonempty_iff_eq_empty]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ p₄ : P
⊢ affineSpan k {p₁, p₂} ∥ affineSpan k {p₃, p₄} ↔ vectorSpan k {p₁, p₂} = vectorSpan k {p₃, p₄}
state_after: no goals
Theorem: Polynomial.span_le_of_C_coeff_mem
File: Mathlib/Algebra/Polynomial/Induction.lean

tactic: simp only [@eq_comm _ _ (C _)]
state_before: R : Type u
S : Type v
T : Type w
ι : Type x
k : Type y
A : Type z
a b : R
m n : ℕ
inst✝ : Semiring R
p q r f : R[X]
I : Ideal R[X]
cf : ∀ (i : ℕ), C (f.coeff i) ∈ I
⊢ Ideal.span {g | ∃ i, g = C (f.coeff i)} ≤ I
state_after: R : Type u
S : Type v
T : Type w
ι : Type x
k : Type y
A : Type z
a b : R
m n : ℕ
inst✝ : Semiring R
p q r f : R[X]
I : Ideal R[X]
cf : ∀ (i : ℕ), C (f.coeff i) ∈ I
⊢ Ideal.span {g | ∃ i, C (f.coeff i) = g} ≤ I

tactic: exact (Ideal.span_le.trans range_subset_iff).mpr cf
state_before: R : Type u
S : Type v
T : Type w
ι : Type x
k : Type y
A : Type z
a b : R
m n : ℕ
inst✝ : Semiring R
p q r f : R[X]
I : Ideal R[X]
cf : ∀ (i : ℕ), C (f.coeff i) ∈ I
⊢ Ideal.span {g | ∃ i, C (f.coeff i) = g} ≤ I
state_after: no goals
Theorem: PicardLindelof.FunSpace.continuous_vComp
File: Mathlib/Analysis/ODE/PicardLindelof.lean

tactic: have := (continuous_subtype_val.prod_mk f.continuous).comp v.continuous_proj
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
f : v.FunSpace
⊢ Continuous f.vComp
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
f : v.FunSpace
this : Continuous ((fun x => (↑x, f.toFun x)) ∘ v.proj)
⊢ Continuous f.vComp

tactic: refine ContinuousOn.comp_continuous v.continuousOn this fun x => ?_
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
f : v.FunSpace
this : Continuous ((fun x => (↑x, f.toFun x)) ∘ v.proj)
⊢ Continuous f.vComp
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
f : v.FunSpace
this : Continuous ((fun x => (↑x, f.toFun x)) ∘ v.proj)
x : ℝ
⊢ ((fun x => (↑x, f.toFun x)) ∘ v.proj) x ∈ Icc v.tMin v.tMax ×ˢ closedBall v.x₀ ↑v.R

tactic: exact ⟨(v.proj x).2, f.mem_closedBall _⟩
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
v : PicardLindelof E
f : v.FunSpace
this : Continuous ((fun x => (↑x, f.toFun x)) ∘ v.proj)
x : ℝ
⊢ ((fun x => (↑x, f.toFun x)) ∘ v.proj) x ∈ Icc v.tMin v.tMax ×ˢ closedBall v.x₀ ↑v.R
state_after: no goals
Theorem: Complex.log_one
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: simp [log]
state_before: ⊢ log 1 = 0
state_after: no goals
Theorem: Polynomial.tendsto_atBot_iff_leadingCoeff_nonpos
File: Mathlib/Analysis/SpecialFunctions/Polynomials.lean

tactic: simp only [← tendsto_neg_atTop_iff, ← eval_neg, tendsto_atTop_iff_leadingCoeff_nonneg,
  degree_neg, leadingCoeff_neg, neg_nonneg]
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
⊢ Tendsto (fun x => eval x P) atTop atBot ↔ 0 < P.degree ∧ P.leadingCoeff ≤ 0
state_after: no goals
Theorem: hasLineDerivWithinAt_zero
File: Mathlib/Analysis/Calculus/LineDeriv/Basic.lean

tactic: simp [HasLineDerivWithinAt, hasDerivWithinAt_const]
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
f : E → F
s : Set E
x : E
⊢ HasLineDerivWithinAt 𝕜 f 0 s x 0
state_after: no goals
Theorem: Matrix.col_smul
File: Mathlib/Data/Matrix/RowCol.lean

tactic: ext
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
inst✝ : SMul R α
x : R
v : m → α
⊢ col ι (x • v) = x • col ι v
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
inst✝ : SMul R α
x : R
v : m → α
i✝ : m
j✝ : ι
⊢ col ι (x • v) i✝ j✝ = (x • col ι v) i✝ j✝

tactic: rfl
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
inst✝ : SMul R α
x : R
v : m → α
i✝ : m
j✝ : ι
⊢ col ι (x • v) i✝ j✝ = (x • col ι v) i✝ j✝
state_after: no goals
Theorem: IsRelPrime.prod_right_iff
File: Mathlib/RingTheory/Coprime/Lemmas.lean

tactic: simpa only [isRelPrime_comm] using IsRelPrime.prod_left_iff (α := α)
state_before: α : Type u_1
I : Type u_2
inst✝¹ : CommMonoid α
inst✝ : DecompositionMonoid α
x y z : α
s : I → α
t : Finset I
⊢ IsRelPrime x (∏ i ∈ t, s i) ↔ ∀ i ∈ t, IsRelPrime x (s i)
state_after: no goals
Theorem: Ordnode.equiv_iff
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [← length_toList h₁, h, length_toList h₂]
state_before: α : Type u_1
t₁ t₂ : Ordnode α
h₁ : t₁.Sized
h₂ : t₂.Sized
h : t₁.toList = t₂.toList
⊢ t₁.size = t₂.size
state_after: no goals
Theorem: MeasureTheory.SimpleFunc.const_mul_lintegral
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simp_rw [Finset.mul_sum, mul_assoc]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α →ₛ ℝ≥0∞
x : ℝ≥0∞
⊢ ∑ r ∈ f.range, x * r * μ (↑f ⁻¹' {r}) = x * ∑ r ∈ f.range, r * μ (↑f ⁻¹' {r})
state_after: no goals
Theorem: FirstOrder.Language.DirectLimit.lift_unique
File: Mathlib/ModelTheory/DirectLimit.lean

tactic: rw [F.comp_apply, F.comp_apply, of_f]
state_before: L : Language
ι : Type v
inst✝⁵ : Preorder ι
G : ι → Type w
inst✝⁴ : (i : ι) → L.Structure (G i)
f : (i j : ι) → i ≤ j → G i ↪[L] G j
inst✝³ : IsDirected ι fun x x_1 => x ≤ x_1
inst✝² : DirectedSystem G fun i j h => ⇑(f i j h)
inst✝¹ : Nonempty ι
P : Type u₁
inst✝ : L.Structure P
g : (i : ι) → G i ↪[L] P
Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) ((f i j hij) x) = (g i) x
F : DirectLimit G f ↪[L] P
x✝ : DirectLimit G f
i j : ι
hij : i ≤ j
x : G i
⊢ ((fun i => F.comp (of L ι G f i)) j) ((f i j hij) x) = ((fun i => F.comp (of L ι G f i)) i) x
state_after: no goals

tactic: rw [lift_of]
state_before: L : Language
ι : Type v
inst✝⁵ : Preorder ι
G : ι → Type w
inst✝⁴ : (i : ι) → L.Structure (G i)
f : (i j : ι) → i ≤ j → G i ↪[L] G j
inst✝³ : IsDirected ι fun x x_1 => x ≤ x_1
inst✝² : DirectedSystem G fun i j h => ⇑(f i j h)
inst✝¹ : Nonempty ι
P : Type u₁
inst✝ : L.Structure P
g : (i : ι) → G i ↪[L] P
Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) ((f i j hij) x) = (g i) x
F : DirectLimit G f ↪[L] P
x✝ : DirectLimit G f
i : ι
x : G i
⊢ F ((of L ι G f i) x) = (lift L ι G f (fun i => F.comp (of L ι G f i)) ⋯) ((of L ι G f i) x)
state_after: L : Language
ι : Type v
inst✝⁵ : Preorder ι
G : ι → Type w
inst✝⁴ : (i : ι) → L.Structure (G i)
f : (i j : ι) → i ≤ j → G i ↪[L] G j
inst✝³ : IsDirected ι fun x x_1 => x ≤ x_1
inst✝² : DirectedSystem G fun i j h => ⇑(f i j h)
inst✝¹ : Nonempty ι
P : Type u₁
inst✝ : L.Structure P
g : (i : ι) → G i ↪[L] P
Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) ((f i j hij) x) = (g i) x
F : DirectLimit G f ↪[L] P
x✝ : DirectLimit G f
i : ι
x : G i
⊢ F ((of L ι G f i) x) = (F.comp (of L ι G f i)) x

tactic: rfl
state_before: L : Language
ι : Type v
inst✝⁵ : Preorder ι
G : ι → Type w
inst✝⁴ : (i : ι) → L.Structure (G i)
f : (i j : ι) → i ≤ j → G i ↪[L] G j
inst✝³ : IsDirected ι fun x x_1 => x ≤ x_1
inst✝² : DirectedSystem G fun i j h => ⇑(f i j h)
inst✝¹ : Nonempty ι
P : Type u₁
inst✝ : L.Structure P
g : (i : ι) → G i ↪[L] P
Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) ((f i j hij) x) = (g i) x
F : DirectLimit G f ↪[L] P
x✝ : DirectLimit G f
i : ι
x : G i
⊢ F ((of L ι G f i) x) = (F.comp (of L ι G f i)) x
state_after: no goals
Theorem: Orientation.areaForm_apply_self
File: Mathlib/Analysis/InnerProductSpace/TwoDim.lean

tactic: rw [areaForm_to_volumeForm]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x : E
⊢ (o.areaForm x) x = 0
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x : E
⊢ o.volumeForm ![x, x] = 0

tactic: refine o.volumeForm.map_eq_zero_of_eq ![x, x] ?_ (?_ : (0 : Fin 2) ≠ 1)
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x : E
⊢ o.volumeForm ![x, x] = 0
state_after: case refine_1
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x : E
⊢ ![x, x] 0 = ![x, x] 1

case refine_2
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x : E
⊢ 0 ≠ 1

tactic: simp
state_before: case refine_1
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x : E
⊢ ![x, x] 0 = ![x, x] 1
state_after: no goals

tactic: norm_num
state_before: case refine_2
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x : E
⊢ 0 ≠ 1
state_after: no goals
Theorem: WithBot.mul_def
File: Mathlib/Algebra/Order/Ring/WithTop.lean

tactic: cases a <;> cases b <;> aesop
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a✝ b✝ a b : WithBot α
⊢ a * b = if a = 0 ∨ b = 0 then 0 else map₂ (fun x x_1 => x * x_1) a b
state_after: no goals
Theorem: SimpleGraph.TripartiteFromTriangles.Graph.in₁₂_iff
File: Mathlib/Combinatorics/SimpleGraph/Triangle/Tripartite.lean

tactic: rintro ⟨⟩
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 : α × β × γ
ε : 𝕜
⊢ (graph t).Adj (in₁ b) (in₂ c) → ∃ a, (a, b, c) ∈ t
state_after: case in₁₂
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
a✝¹ : α
a✝ : (a✝¹, b, c) ∈ t
⊢ ∃ a, (a, b, c) ∈ t

tactic: exact ⟨_, ‹_›⟩
state_before: case in₁₂
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
a✝¹ : α
a✝ : (a✝¹, b, c) ∈ t
⊢ ∃ a, (a, b, c) ∈ t
state_after: no goals
Theorem: CategoryTheory.Functor.hasRightDerivedFunctor_iff_of_iso
File: Mathlib/CategoryTheory/Functor/Derived/RightDerived.lean

tactic: rw [hasRightDerivedFunctor_iff F W.Q W, hasRightDerivedFunctor_iff F' W.Q W,
  hasLeftExtension_iff_of_iso₂ W.Q e]
state_before: C : Type u_1
C' : Type ?u.85864
D : Type ?u.85867
D' : Type ?u.85870
H : Type u_2
H' : Type ?u.85876
inst✝⁶ : Category.{u_3, u_1} C
inst✝⁵ : Category.{?u.85884, ?u.85864} C'
inst✝⁴ : Category.{?u.85888, ?u.85867} D
inst✝³ : Category.{?u.85892, ?u.85870} D'
inst✝² : Category.{u_4, u_2} H
inst✝¹ : Category.{?u.85900, ?u.85876} H'
RF RF' RF'' : D ⥤ H
F F' F'' : C ⥤ H
e : F ≅ F'
L : C ⥤ D
α : F ⟶ L ⋙ RF
α' : F' ⟶ L ⋙ RF'
α'' : F'' ⟶ L ⋙ RF''
α'₂ : F ⟶ L ⋙ RF'
W : MorphismProperty C
inst✝ : L.IsLocalization W
⊢ F.HasRightDerivedFunctor W ↔ F'.HasRightDerivedFunctor W
state_after: no goals
Theorem: Set.image_div_const_uIcc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp only [div_eq_mul_inv, image_mul_const_uIcc]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
⊢ (fun x => x / a) '' [[b, c]] = [[b / a, c / a]]
state_after: no goals
Theorem: ArithmeticFunction.sum_eq_iff_sum_mul_moebius_eq_on
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: rw [sum_eq_iff_sum_smul_moebius_eq_on s hs]
state_before: R : Type u_1
inst✝ : Ring R
f g : ℕ → R
s : Set ℕ
hs : ∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s
⊢ (∀ n > 0, n ∈ s → ∑ i ∈ n.divisors, f i = g n) ↔ ∀ n > 0, n ∈ s → ∑ x ∈ n.divisorsAntidiagonal, ↑(μ x.1) * g x.2 = f n
state_after: R : Type u_1
inst✝ : Ring R
f g : ℕ → R
s : Set ℕ
hs : ∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s
⊢ (∀ n > 0, n ∈ s → ∑ x ∈ n.divisorsAntidiagonal, μ x.1 • g x.2 = f n) ↔
    ∀ n > 0, n ∈ s → ∑ x ∈ n.divisorsAntidiagonal, ↑(μ x.1) * g x.2 = f n

tactic: apply forall_congr'
state_before: R : Type u_1
inst✝ : Ring R
f g : ℕ → R
s : Set ℕ
hs : ∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s
⊢ (∀ n > 0, n ∈ s → ∑ x ∈ n.divisorsAntidiagonal, μ x.1 • g x.2 = f n) ↔
    ∀ n > 0, n ∈ s → ∑ x ∈ n.divisorsAntidiagonal, ↑(μ x.1) * g x.2 = f n
state_after: case h
R : Type u_1
inst✝ : Ring R
f g : ℕ → R
s : Set ℕ
hs : ∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s
⊢ ∀ (a : ℕ),
    a > 0 → a ∈ s → ∑ x ∈ a.divisorsAntidiagonal, μ x.1 • g x.2 = f a ↔
      a > 0 → a ∈ s → ∑ x ∈ a.divisorsAntidiagonal, ↑(μ x.1) * g x.2 = f a

tactic: intro a
state_before: case h
R : Type u_1
inst✝ : Ring R
f g : ℕ → R
s : Set ℕ
hs : ∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s
⊢ ∀ (a : ℕ),
    a > 0 → a ∈ s → ∑ x ∈ a.divisorsAntidiagonal, μ x.1 • g x.2 = f a ↔
      a > 0 → a ∈ s → ∑ x ∈ a.divisorsAntidiagonal, ↑(μ x.1) * g x.2 = f a
state_after: case h
R : Type u_1
inst✝ : Ring R
f g : ℕ → R
s : Set ℕ
hs : ∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s
a : ℕ
⊢ a > 0 → a ∈ s → ∑ x ∈ a.divisorsAntidiagonal, μ x.1 • g x.2 = f a ↔
    a > 0 → a ∈ s → ∑ x ∈ a.divisorsAntidiagonal, ↑(μ x.1) * g x.2 = f a

tactic: refine imp_congr_right ?_
state_before: case h
R : Type u_1
inst✝ : Ring R
f g : ℕ → R
s : Set ℕ
hs : ∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s
a : ℕ
⊢ a > 0 → a ∈ s → ∑ x ∈ a.divisorsAntidiagonal, μ x.1 • g x.2 = f a ↔
    a > 0 → a ∈ s → ∑ x ∈ a.divisorsAntidiagonal, ↑(μ x.1) * g x.2 = f a
state_after: case h
R : Type u_1
inst✝ : Ring R
f g : ℕ → R
s : Set ℕ
hs : ∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s
a : ℕ
⊢ a > 0 →
    (a ∈ s → ∑ x ∈ a.divisorsAntidiagonal, μ x.1 • g x.2 = f a ↔
      a ∈ s → ∑ x ∈ a.divisorsAntidiagonal, ↑(μ x.1) * g x.2 = f a)

tactic: refine fun _ => imp_congr_right fun _ => (sum_congr rfl fun x _hx => ?_).congr_left
state_before: case h
R : Type u_1
inst✝ : Ring R
f g : ℕ → R
s : Set ℕ
hs : ∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s
a : ℕ
⊢ a > 0 →
    (a ∈ s → ∑ x ∈ a.divisorsAntidiagonal, μ x.1 • g x.2 = f a ↔
      a ∈ s → ∑ x ∈ a.divisorsAntidiagonal, ↑(μ x.1) * g x.2 = f a)
state_after: case h
R : Type u_1
inst✝ : Ring R
f g : ℕ → R
s : Set ℕ
hs : ∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s
a : ℕ
x✝¹ : a > 0
x✝ : a ∈ s
x : ℕ × ℕ
_hx : x ∈ a.divisorsAntidiagonal
⊢ μ x.1 • g x.2 = ↑(μ x.1) * g x.2

tactic: rw [zsmul_eq_mul]
state_before: case h
R : Type u_1
inst✝ : Ring R
f g : ℕ → R
s : Set ℕ
hs : ∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s
a : ℕ
x✝¹ : a > 0
x✝ : a ∈ s
x : ℕ × ℕ
_hx : x ∈ a.divisorsAntidiagonal
⊢ μ x.1 • g x.2 = ↑(μ x.1) * g x.2
state_after: no goals
Theorem: toIcoMod_add_right'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [one_zsmul] using toIcoMod_add_zsmul' hp a b 1
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoMod hp (a + p) b = toIcoMod hp a b + p
state_after: no goals
Theorem: Sum.LiftRel.swap
File: .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean

tactic: cases h
state_before: α✝¹ : Type u_1
α✝ : Type u_2
r : α✝¹ → α✝ → Prop
β✝¹ : Type u_3
β✝ : Type u_4
s : β✝¹ → β✝ → Prop
x : α✝¹ ⊕ β✝¹
y : α✝ ⊕ β✝
h : LiftRel r s x y
⊢ LiftRel s r x.swap y.swap
state_after: case inl
α✝¹ : Type u_1
α✝ : Type u_2
r : α✝¹ → α✝ → Prop
β✝¹ : Type u_3
β✝ : Type u_4
s : β✝¹ → β✝ → Prop
a✝¹ : α✝¹
c✝ : α✝
a✝ : r a✝¹ c✝
⊢ LiftRel s r (inl a✝¹).swap (inl c✝).swap

case inr
α✝¹ : Type u_1
α✝ : Type u_2
r : α✝¹ → α✝ → Prop
β✝¹ : Type u_3
β✝ : Type u_4
s : β✝¹ → β✝ → Prop
b✝ : β✝¹
d✝ : β✝
a✝ : s b✝ d✝
⊢ LiftRel s r (inr b✝).swap (inr d✝).swap

tactic: exact LiftRel.inr ‹_›
state_before: case inl
α✝¹ : Type u_1
α✝ : Type u_2
r : α✝¹ → α✝ → Prop
β✝¹ : Type u_3
β✝ : Type u_4
s : β✝¹ → β✝ → Prop
a✝¹ : α✝¹
c✝ : α✝
a✝ : r a✝¹ c✝
⊢ LiftRel s r (inl a✝¹).swap (inl c✝).swap
state_after: no goals

tactic: exact LiftRel.inl ‹_›
state_before: case inr
α✝¹ : Type u_1
α✝ : Type u_2
r : α✝¹ → α✝ → Prop
β✝¹ : Type u_3
β✝ : Type u_4
s : β✝¹ → β✝ → Prop
b✝ : β✝¹
d✝ : β✝
a✝ : s b✝ d✝
⊢ LiftRel s r (inr b✝).swap (inr d✝).swap
state_after: no goals
Theorem: Vector.map_eq_mapAccumr
File: Mathlib/Data/Vector/MapLemmas.lean

tactic: clear ys
state_before: α : Type u_2
n : ℕ
β : Type ?u.28475
xs : Vector α n
ys : Vector β n
α✝ : Type u_1
f : α → α✝
⊢ map f xs = (mapAccumr (fun x x_1 => ((), f x)) xs ()).2
state_after: α : Type u_2
n : ℕ
β : Type ?u.28475
xs : Vector α n
α✝ : Type u_1
f : α → α✝
⊢ map f xs = (mapAccumr (fun x x_1 => ((), f x)) xs ()).2

tactic: induction xs using Vector.revInductionOn <;> simp_all
state_before: α : Type u_2
n : ℕ
β : Type ?u.28475
xs : Vector α n
α✝ : Type u_1
f : α → α✝
⊢ map f xs = (mapAccumr (fun x x_1 => ((), f x)) xs ()).2
state_after: no goals
Theorem: Matroid.eq_of_indep_iff_indep_forall
File: Mathlib/Data/Matroid/Basic.lean

tactic: simp_rw [base_iff_maximal_indep, h']
state_before: α : Type u_1
M M₁ M₂ : Matroid α
hE : M₁.E = M₂.E
h : ∀ I ⊆ M₁.E, M₁.Indep I ↔ M₂.Indep I
h' : ∀ (I : Set α), M₁.Indep I ↔ M₂.Indep I :=
  fun I =>
    Or.elim (em (I ⊆ M₁.E)) (h I) fun h' =>
      iff_of_false (fun hi => h' (Indep.subset_ground hi)) fun hi =>
        h' (LE.le.trans_eq (Indep.subset_ground hi) (Eq.symm hE))
B : Set α
x✝ : B ⊆ M₁.E
⊢ M₁.Base B ↔ M₂.Base B
state_after: no goals
Theorem: sSup_compact_le_eq
File: Mathlib/Order/CompactlyGenerated/Basic.lean

tactic: rcases IsCompactlyGenerated.exists_sSup_eq b with ⟨s, hs, rfl⟩
state_before: ι : Sort u_1
α : Type u_2
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
a b✝ : α
s : Set α
b : α
⊢ sSup {c | CompleteLattice.IsCompactElement c ∧ c ≤ b} = b
state_after: case intro.intro
ι : Sort u_1
α : Type u_2
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
a b : α
s✝ s : Set α
hs : ∀ x ∈ s, CompleteLattice.IsCompactElement x
⊢ sSup {c | CompleteLattice.IsCompactElement c ∧ c ≤ sSup s} = sSup s

tactic: exact le_antisymm (sSup_le fun c hc => hc.2) (sSup_le_sSup fun c cs => ⟨hs c cs, le_sSup cs⟩)
state_before: case intro.intro
ι : Sort u_1
α : Type u_2
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
a b : α
s✝ s : Set α
hs : ∀ x ∈ s, CompleteLattice.IsCompactElement x
⊢ sSup {c | CompleteLattice.IsCompactElement c ∧ c ≤ sSup s} = sSup s
state_after: no goals
Theorem: MeasureTheory.measurePreserving_mul_prod_inv
File: Mathlib/MeasureTheory/Group/Prod.lean

tactic: convert (measurePreserving_prod_inv_mul_swap ν μ).comp (measurePreserving_prod_mul_swap μ ν)
  using 1
state_before: G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : ν.IsMulLeftInvariant
⊢ MeasurePreserving (fun z => (z.2 * z.1, z.1⁻¹)) (μ.prod ν) (μ.prod ν)
state_after: case h.e'_5
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : ν.IsMulLeftInvariant
⊢ (fun z => (z.2 * z.1, z.1⁻¹)) = (fun z => (z.2, z.2⁻¹ * z.1)) ∘ fun z => (z.2, z.2 * z.1)

tactic: ext1 ⟨x, y⟩
state_before: case h.e'_5
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : ν.IsMulLeftInvariant
⊢ (fun z => (z.2 * z.1, z.1⁻¹)) = (fun z => (z.2, z.2⁻¹ * z.1)) ∘ fun z => (z.2, z.2 * z.1)
state_after: case h.e'_5.h.mk
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : ν.IsMulLeftInvariant
x y : G
⊢ ((x, y).2 * (x, y).1, (x, y).1⁻¹) = ((fun z => (z.2, z.2⁻¹ * z.1)) ∘ fun z => (z.2, z.2 * z.1)) (x, y)

tactic: simp_rw [Function.comp_apply, mul_inv_rev, inv_mul_cancel_right]
state_before: case h.e'_5.h.mk
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : μ.IsMulLeftInvariant
inst✝ : ν.IsMulLeftInvariant
x y : G
⊢ ((x, y).2 * (x, y).1, (x, y).1⁻¹) = ((fun z => (z.2, z.2⁻¹ * z.1)) ∘ fun z => (z.2, z.2 * z.1)) (x, y)
state_after: no goals