1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Polynomial.natDegree_removeFactor'
File: Mathlib/FieldTheory/SplittingField/Construction.lean

tactic: rw [natDegree_removeFactor, hfn, n.add_sub_cancel]
state_before: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
f : K[X]
n : ℕ
hfn : f.natDegree = n + 1
⊢ f.removeFactor.natDegree = n
state_after: no goals
Theorem: mul_mem_closedBall_mul_iff
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simp only [mem_closedBall, dist_eq_norm_div, mul_div_mul_right_eq_div]
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
c : E
⊢ a * c ∈ closedBall (b * c) r ↔ a ∈ closedBall b r
state_after: no goals
Theorem: Filter.HasBasis.equicontinuousAt_iff_left
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

tactic: rw [equicontinuousAt_iff_continuousAt, ContinuousAt,
  hX.tendsto_iff (UniformFun.hasBasis_nhds ι α _)]
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
p : κ → Prop
s : κ → Set X
F : ι → X → α
x₀ : X
hX : (𝓝 x₀).HasBasis p s
⊢ EquicontinuousAt F x₀ ↔ ∀ U ∈ 𝓤 α, ∃ k, p k ∧ ∀ x ∈ s k, ∀ (i : ι), (F i x₀, F i x) ∈ U
state_after: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
p : κ → Prop
s : κ → Set X
F : ι → X → α
x₀ : X
hX : (𝓝 x₀).HasBasis p s
⊢ (∀ ib ∈ 𝓤 α,
      ∃ ia,
        p ia ∧
          ∀ x ∈ s ia,
            (⇑UniformFun.ofFun ∘ swap F) x ∈ {g | ((⇑UniformFun.ofFun ∘ swap F) x₀, g) ∈ UniformFun.gen ι α ib}) ↔
    ∀ U ∈ 𝓤 α, ∃ k, p k ∧ ∀ x ∈ s k, ∀ (i : ι), (F i x₀, F i x) ∈ U

tactic: rfl
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
p : κ → Prop
s : κ → Set X
F : ι → X → α
x₀ : X
hX : (𝓝 x₀).HasBasis p s
⊢ (∀ ib ∈ 𝓤 α,
      ∃ ia,
        p ia ∧
          ∀ x ∈ s ia,
            (⇑UniformFun.ofFun ∘ swap F) x ∈ {g | ((⇑UniformFun.ofFun ∘ swap F) x₀, g) ∈ UniformFun.gen ι α ib}) ↔
    ∀ U ∈ 𝓤 α, ∃ k, p k ∧ ∀ x ∈ s k, ∀ (i : ι), (F i x₀, F i x) ∈ U
state_after: no goals
Theorem: MeasureTheory.ProbabilityMeasure.tendsto_iff_forall_integral_tendsto
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

tactic: rw [tendsto_nhds_iff_toFiniteMeasure_tendsto_nhds]
state_before: Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_2
F : Filter γ
μs : γ → ProbabilityMeasure Ω
μ : ProbabilityMeasure Ω
⊢ Tendsto μs F (𝓝 μ) ↔ ∀ (f : Ω →ᵇ ℝ), Tendsto (fun i => ∫ (ω : Ω), f ω ∂↑(μs i)) F (𝓝 (∫ (ω : Ω), f ω ∂↑μ))
state_after: Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_2
F : Filter γ
μs : γ → ProbabilityMeasure Ω
μ : ProbabilityMeasure Ω
⊢ Tendsto (toFiniteMeasure ∘ μs) F (𝓝 μ.toFiniteMeasure) ↔
    ∀ (f : Ω →ᵇ ℝ), Tendsto (fun i => ∫ (ω : Ω), f ω ∂↑(μs i)) F (𝓝 (∫ (ω : Ω), f ω ∂↑μ))

tactic: rw [FiniteMeasure.tendsto_iff_forall_integral_tendsto]
state_before: Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_2
F : Filter γ
μs : γ → ProbabilityMeasure Ω
μ : ProbabilityMeasure Ω
⊢ Tendsto (toFiniteMeasure ∘ μs) F (𝓝 μ.toFiniteMeasure) ↔
    ∀ (f : Ω →ᵇ ℝ), Tendsto (fun i => ∫ (ω : Ω), f ω ∂↑(μs i)) F (𝓝 (∫ (ω : Ω), f ω ∂↑μ))
state_after: Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_2
F : Filter γ
μs : γ → ProbabilityMeasure Ω
μ : ProbabilityMeasure Ω
⊢ (∀ (f : Ω →ᵇ ℝ),
      Tendsto (fun i => ∫ (x : Ω), f x ∂↑((toFiniteMeasure ∘ μs) i)) F (𝓝 (∫ (x : Ω), f x ∂↑μ.toFiniteMeasure))) ↔
    ∀ (f : Ω →ᵇ ℝ), Tendsto (fun i => ∫ (ω : Ω), f ω ∂↑(μs i)) F (𝓝 (∫ (ω : Ω), f ω ∂↑μ))

tactic: rfl
state_before: Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_2
F : Filter γ
μs : γ → ProbabilityMeasure Ω
μ : ProbabilityMeasure Ω
⊢ (∀ (f : Ω →ᵇ ℝ),
      Tendsto (fun i => ∫ (x : Ω), f x ∂↑((toFiniteMeasure ∘ μs) i)) F (𝓝 (∫ (x : Ω), f x ∂↑μ.toFiniteMeasure))) ↔
    ∀ (f : Ω →ᵇ ℝ), Tendsto (fun i => ∫ (ω : Ω), f ω ∂↑(μs i)) F (𝓝 (∫ (ω : Ω), f ω ∂↑μ))
state_after: no goals
Theorem: Metric.cthickening_of_nonpos
File: Mathlib/Topology/MetricSpace/Thickening.lean

tactic: ext x
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
δ : ℝ
hδ : δ ≤ 0
E : Set α
⊢ cthickening δ E = closure E
state_after: case h
ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x✝ : α
δ : ℝ
hδ : δ ≤ 0
E : Set α
x : α
⊢ x ∈ cthickening δ E ↔ x ∈ closure E

tactic: simp [mem_closure_iff_infEdist_zero, cthickening, ENNReal.ofReal_eq_zero.2 hδ]
state_before: case h
ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x✝ : α
δ : ℝ
hδ : δ ≤ 0
E : Set α
x : α
⊢ x ∈ cthickening δ E ↔ x ∈ closure E
state_after: no goals
Theorem: Subsemigroup.closure_singleton_le_iff_mem
File: Mathlib/Algebra/Group/Subsemigroup/Basic.lean

tactic: rw [closure_le, singleton_subset_iff, SetLike.mem_coe]
state_before: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : Mul M
s : Set M
inst✝ : Add A
t : Set A
S : Subsemigroup M
m : M
p : Subsemigroup M
⊢ closure {m} ≤ p ↔ m ∈ p
state_after: no goals
Theorem: WittVector.wittSub_zero
File: Mathlib/RingTheory/WittVector/Defs.lean

tactic: apply MvPolynomial.map_injective (Int.castRingHom ℚ) Int.cast_injective
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
⊢ wittSub p 0 = X (0, 0) - X (1, 0)
state_after: case a
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
⊢ (map (Int.castRingHom ℚ)) (wittSub p 0) = (map (Int.castRingHom ℚ)) (X (0, 0) - X (1, 0))

tactic: simp only [wittSub, wittStructureRat, AlgHom.map_sub, RingHom.map_sub, rename_X,
  xInTermsOfW_zero, map_X, wittPolynomial_zero, bind₁_X_right, map_wittStructureInt]
state_before: case a
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
⊢ (map (Int.castRingHom ℚ)) (wittSub p 0) = (map (Int.castRingHom ℚ)) (X (0, 0) - X (1, 0))
state_after: no goals
Theorem: Finset.inter_comm
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [mem_inter, and_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a b : α
s₁ s₂ : Finset α
x✝ : α
⊢ x✝ ∈ s₁ ∩ s₂ ↔ x✝ ∈ s₂ ∩ s₁
state_after: no goals
Theorem: WittVector.toPadicInt_comp_fromPadicInt
File: Mathlib/RingTheory/WittVector/Compare.lean

tactic: rw [← PadicInt.toZModPow_eq_iff_ext]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
⊢ (toPadicInt p).comp (fromPadicInt p) = RingHom.id ℤ_[p]
state_after: p : ℕ
hp : Fact (Nat.Prime p)
⊢ ∀ (n : ℕ),
    (PadicInt.toZModPow n).comp ((toPadicInt p).comp (fromPadicInt p)) = (PadicInt.toZModPow n).comp (RingHom.id ℤ_[p])

tactic: intro n
state_before: p : ℕ
hp : Fact (Nat.Prime p)
⊢ ∀ (n : ℕ),
    (PadicInt.toZModPow n).comp ((toPadicInt p).comp (fromPadicInt p)) = (PadicInt.toZModPow n).comp (RingHom.id ℤ_[p])
state_after: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
⊢ (PadicInt.toZModPow n).comp ((toPadicInt p).comp (fromPadicInt p)) = (PadicInt.toZModPow n).comp (RingHom.id ℤ_[p])

tactic: rw [← RingHom.comp_assoc, toPadicInt, PadicInt.lift_spec]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
⊢ (PadicInt.toZModPow n).comp ((toPadicInt p).comp (fromPadicInt p)) = (PadicInt.toZModPow n).comp (RingHom.id ℤ_[p])
state_after: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
⊢ (toZModPow p n).comp (fromPadicInt p) = (PadicInt.toZModPow n).comp (RingHom.id ℤ_[p])

tactic: simp only [fromPadicInt, toZModPow, RingHom.comp_id]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
⊢ (toZModPow p n).comp (fromPadicInt p) = (PadicInt.toZModPow n).comp (RingHom.id ℤ_[p])
state_after: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
⊢ ((zmodEquivTrunc p n).symm.toRingHom.comp (truncate n)).comp
      (lift (fun k => (zmodEquivTrunc p k).toRingHom.comp (PadicInt.toZModPow k)) ⋯) =
    PadicInt.toZModPow n

tactic: rw [RingHom.comp_assoc, truncate_comp_lift, ← RingHom.comp_assoc]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
⊢ ((zmodEquivTrunc p n).symm.toRingHom.comp (truncate n)).comp
      (lift (fun k => (zmodEquivTrunc p k).toRingHom.comp (PadicInt.toZModPow k)) ⋯) =
    PadicInt.toZModPow n
state_after: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
⊢ ((zmodEquivTrunc p n).symm.toRingHom.comp (zmodEquivTrunc p n).toRingHom).comp (PadicInt.toZModPow n) =
    PadicInt.toZModPow n

tactic: simp only [RingEquiv.symm_toRingHom_comp_toRingHom, RingHom.id_comp]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
⊢ ((zmodEquivTrunc p n).symm.toRingHom.comp (zmodEquivTrunc p n).toRingHom).comp (PadicInt.toZModPow n) =
    PadicInt.toZModPow n
state_after: no goals
Theorem: NormedSpace.exp_op
File: Mathlib/Analysis/NormedSpace/Exponential.lean

tactic: simp_rw [exp, expSeries_sum_eq, ← MulOpposite.op_pow, ← MulOpposite.op_smul, tsum_op]
state_before: 𝕂 : Type u_1
𝔸 : Type u_2
inst✝⁵ : Field 𝕂
inst✝⁴ : Ring 𝔸
inst✝³ : Algebra 𝕂 𝔸
inst✝² : TopologicalSpace 𝔸
inst✝¹ : TopologicalRing 𝔸
inst✝ : T2Space 𝔸
x : 𝔸
⊢ exp 𝕂 (MulOpposite.op x) = MulOpposite.op (exp 𝕂 x)
state_after: no goals
Theorem: Profinite.NobelingProof.mem_C'_eq_false
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

tactic: rintro x ⟨_, y, _, rfl⟩
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
⊢ ∀ x ∈ C' C ho, x (term I ho) = false
state_after: case intro.intro.intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
y : I → Bool
left✝¹ : y ∈ C1 C ho
left✝ : Proj (fun x => ord I x < o) y ∈ C0 C ho
⊢ Proj (fun x => ord I x < o) y (term I ho) = false

tactic: simp only [Proj, ord_term_aux, lt_self_iff_false, ite_false]
state_before: case intro.intro.intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
hC : IsClosed C
hsC : contained C (Order.succ o)
ho : o < Ordinal.type fun x x_1 => x < x_1
y : I → Bool
left✝¹ : y ∈ C1 C ho
left✝ : Proj (fun x => ord I x < o) y ∈ C0 C ho
⊢ Proj (fun x => ord I x < o) y (term I ho) = false
state_after: no goals
Theorem: MeasureTheory.Measure.rnDeriv_withDensity_rnDeriv
File: Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean

tactic: conv_rhs => rw [ν.haveLebesgueDecomposition_add μ, add_comm]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
hμν : μ ≪ ν
⊢ μ.rnDeriv (μ.withDensity (ν.rnDeriv μ)) =ᶠ[ae μ] μ.rnDeriv ν
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
hμν : μ ≪ ν
⊢ μ.rnDeriv (μ.withDensity (ν.rnDeriv μ)) =ᶠ[ae μ] μ.rnDeriv (μ.withDensity (ν.rnDeriv μ) + ν.singularPart μ)

tactic: refine (absolutelyContinuous_withDensity_rnDeriv hμν).ae_eq ?_
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
hμν : μ ≪ ν
⊢ μ.rnDeriv (μ.withDensity (ν.rnDeriv μ)) =ᶠ[ae μ] μ.rnDeriv (μ.withDensity (ν.rnDeriv μ) + ν.singularPart μ)
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
hμν : μ ≪ ν
⊢ μ.rnDeriv (μ.withDensity (ν.rnDeriv μ)) =ᶠ[ae (μ.withDensity (ν.rnDeriv μ))]
    μ.rnDeriv (μ.withDensity (ν.rnDeriv μ) + ν.singularPart μ)

tactic: exact (rnDeriv_add_right_of_mutuallySingular
  (Measure.mutuallySingular_singularPart ν μ).symm.withDensity).symm
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
hμν : μ ≪ ν
⊢ μ.rnDeriv (μ.withDensity (ν.rnDeriv μ)) =ᶠ[ae (μ.withDensity (ν.rnDeriv μ))]
    μ.rnDeriv (μ.withDensity (ν.rnDeriv μ) + ν.singularPart μ)
state_after: no goals
Theorem: DFinsupp.card_pi
File: Mathlib/Data/DFinsupp/Interval.lean

tactic: rw [pi, card_dfinsupp]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝² : (i : ι) → Zero (α i)
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (α i)
f : Π₀ (i : ι), Finset (α i)
⊢ f.pi.card = f.prod fun i => ↑(f i).card
state_after: ι : Type u_1
α : ι → Type u_2
inst✝² : (i : ι) → Zero (α i)
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (α i)
f : Π₀ (i : ι), Finset (α i)
⊢ ∏ i ∈ f.support, (f i).card = f.prod fun i => ↑(f i).card

tactic: exact Finset.prod_congr rfl fun i _ => by simp only [Pi.natCast_apply, Nat.cast_id]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝² : (i : ι) → Zero (α i)
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (α i)
f : Π₀ (i : ι), Finset (α i)
⊢ ∏ i ∈ f.support, (f i).card = f.prod fun i => ↑(f i).card
state_after: no goals

tactic: simp only [Pi.natCast_apply, Nat.cast_id]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝² : (i : ι) → Zero (α i)
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (α i)
f : Π₀ (i : ι), Finset (α i)
i : ι
x✝ : i ∈ f.support
⊢ (f i).card = (fun i => ↑(f i).card) i (f i)
state_after: no goals
Theorem: Nat.ppred_eq_some
File: Mathlib/Data/Nat/PSub.lean

tactic: constructor <;> intro h <;> contradiction
state_before: m : ℕ
⊢ ppred 0 = some m ↔ m.succ = 0
state_after: no goals

tactic: constructor <;> intro h <;> injection h <;> subst m <;> rfl
state_before: m n : ℕ
⊢ (n + 1).ppred = some m ↔ m.succ = n + 1
state_after: no goals
Theorem: IsSubgroup.trivial_normal
File: Mathlib/Deprecated/Subgroup.lean

tactic: refine ⟨⟨⟨?_, ?_⟩, ?_⟩, ?_⟩ <;> simp
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝ : Group G
⊢ IsNormalSubgroup (trivial G)
state_after: no goals
Theorem: CategoryTheory.ShortComplex.RightHomologyData.ofEpiOfIsIsoOfMono'_g'_τ₃
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

tactic: rw [← cancel_epi (ofEpiOfIsIsoOfMono' φ h).p, p_g'_assoc, ofEpiOfIsIsoOfMono'_p,
  assoc, p_g', φ.comm₂₃]
state_before: C : Type u_1
inst✝⁴ : Category.{u_2, u_1} C
inst✝³ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
φ : S₁ ⟶ S₂
h : S₂.RightHomologyData
inst✝² : Epi φ.τ₁
inst✝¹ : IsIso φ.τ₂
inst✝ : Mono φ.τ₃
⊢ (ofEpiOfIsIsoOfMono' φ h).g' ≫ φ.τ₃ = h.g'
state_after: no goals
Theorem: FinVec.exists_iff
File: Mathlib/Data/Fin/Tuple/Reflection.lean

tactic: simp only [Exists, Fin.exists_fin_zero_pi, Matrix.vecEmpty]
state_before: m n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
P : (Fin 0 → α) → Prop
⊢ Exists P ↔ ∃ x, P x
state_after: m n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
P : (Fin 0 → α) → Prop
⊢ P Fin.elim0 ↔ P finZeroElim

tactic: rfl
state_before: m n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
P : (Fin 0 → α) → Prop
⊢ P Fin.elim0 ↔ P finZeroElim
state_after: no goals

tactic: simp only [Exists, exists_iff, Fin.exists_fin_succ_pi, Matrix.vecCons]
state_before: m n✝ : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
P : (Fin n.succ → α) → Prop
⊢ Exists P ↔ ∃ x, P x
state_after: no goals
Theorem: Batteries.PairingHeapImp.Heap.size_tail?
File: .lake/packages/batteries/Batteries/Data/PairingHeap.lean

tactic: simp only [Heap.tail?]
state_before: α : Type u_1
le : α → α → Bool
s' s : Heap α
h : s.NoSibling
⊢ tail? le s = some s' → s.size = s'.size + 1
state_after: α : Type u_1
le : α → α → Bool
s' s : Heap α
h : s.NoSibling
⊢ Option.map (fun x => x.snd) (deleteMin le s) = some s' → s.size = s'.size + 1

tactic: intro eq
state_before: α : Type u_1
le : α → α → Bool
s' s : Heap α
h : s.NoSibling
⊢ Option.map (fun x => x.snd) (deleteMin le s) = some s' → s.size = s'.size + 1
state_after: α : Type u_1
le : α → α → Bool
s' s : Heap α
h : s.NoSibling
eq : Option.map (fun x => x.snd) (deleteMin le s) = some s'
⊢ s.size = s'.size + 1

tactic: match eq₂ : s.deleteMin le, eq with
| some (a, tl), rfl => exact size_deleteMin h eq₂
state_before: α : Type u_1
le : α → α → Bool
s' s : Heap α
h : s.NoSibling
eq : Option.map (fun x => x.snd) (deleteMin le s) = some s'
⊢ s.size = s'.size + 1
state_after: no goals

tactic: exact size_deleteMin h eq₂
state_before: α : Type u_1
le : α → α → Bool
s' s : Heap α
h : s.NoSibling
eq : Option.map (fun x => x.snd) (deleteMin le s) = some s'
a : α
tl : Heap α
eq₂ : deleteMin le s = some (a, tl)
⊢ s.size = ((fun x => x.snd) (a, tl)).size + 1
state_after: no goals
Theorem: IsRelPrime.mul_dvd_of_right_isPrimal
File: Mathlib/Algebra/Divisibility/Units.lean

tactic: obtain ⟨w, rfl⟩ := H1
state_before: α : Type u_1
inst✝ : CommMonoid α
x y z : α
H : IsRelPrime x y
H1 : x ∣ z
H2 : y ∣ z
hy : IsPrimal y
⊢ x * y ∣ z
state_after: case intro
α : Type u_1
inst✝ : CommMonoid α
x y : α
H : IsRelPrime x y
hy : IsPrimal y
w : α
H2 : y ∣ x * w
⊢ x * y ∣ x * w

tactic: exact mul_dvd_mul_left x (H.symm.dvd_of_dvd_mul_left_of_isPrimal H2 hy)
state_before: case intro
α : Type u_1
inst✝ : CommMonoid α
x y : α
H : IsRelPrime x y
hy : IsPrimal y
w : α
H2 : y ∣ x * w
⊢ x * y ∣ x * w
state_after: no goals
Theorem: ProbabilityTheory.IsMeasurableRatCDF.stieltjesFunctionAux_nonneg
File: Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean

tactic: have : Nonempty { r' : ℚ // r < ↑r' } := by
  obtain ⟨r, hrx⟩ := exists_rat_gt r
  exact ⟨⟨r, hrx⟩⟩
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
r : ℝ
⊢ 0 ≤ stieltjesFunctionAux f a r
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
r : ℝ
this : Nonempty { r' // r < ↑r' }
⊢ 0 ≤ stieltjesFunctionAux f a r

tactic: rw [IsMeasurableRatCDF.stieltjesFunctionAux_def]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
r : ℝ
this : Nonempty { r' // r < ↑r' }
⊢ 0 ≤ stieltjesFunctionAux f a r
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
r : ℝ
this : Nonempty { r' // r < ↑r' }
⊢ 0 ≤ ⨅ q, f a ↑q

tactic: exact le_ciInf fun r' ↦ hf.nonneg a _
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
r : ℝ
this : Nonempty { r' // r < ↑r' }
⊢ 0 ≤ ⨅ q, f a ↑q
state_after: no goals

tactic: obtain ⟨r, hrx⟩ := exists_rat_gt r
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
r : ℝ
⊢ Nonempty { r' // r < ↑r' }
state_after: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
r✝ : ℝ
r : ℚ
hrx : r✝ < ↑r
⊢ Nonempty { r' // r✝ < ↑r' }

tactic: exact ⟨⟨r, hrx⟩⟩
state_before: case intro
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
r✝ : ℝ
r : ℚ
hrx : r✝ < ↑r
⊢ Nonempty { r' // r✝ < ↑r' }
state_after: no goals
Theorem: Embedding.isTotallyDisconnected_range
File: Mathlib/Topology/Connected/TotallyDisconnected.lean

tactic: rw [totallyDisconnectedSpace_iff, ← image_univ, hf.isTotallyDisconnected_image]
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝¹ : TopologicalSpace α
s t u v : Set α
inst✝ : TopologicalSpace β
f : α → β
hf : _root_.Embedding f
⊢ IsTotallyDisconnected (range f) ↔ TotallyDisconnectedSpace α
state_after: no goals
Theorem: LinearMap.mem_skewAdjointSubmodule
File: Mathlib/LinearAlgebra/SesquilinearForm.lean

tactic: rw [isSkewAdjoint_iff_neg_self_adjoint]
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
Mₗ₁ : Type u_9
Mₗ₁' : Type u_10
Mₗ₂ : Type u_11
Mₗ₂' : Type u_12
K : Type u_13
K₁ : Type u_14
K₂ : Type u_15
V : Type u_16
V₁ : Type u_17
V₂ : Type u_18
n : Type u_19
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : AddCommGroup M₁
inst✝² : Module R M₁
inst✝¹ : AddCommGroup M₂
inst✝ : Module R M₂
B F : M →ₗ[R] M →ₗ[R] M₂
f : Module.End R M
⊢ f ∈ B.skewAdjointSubmodule ↔ B.IsSkewAdjoint f
state_after: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
Mₗ₁ : Type u_9
Mₗ₁' : Type u_10
Mₗ₂ : Type u_11
Mₗ₂' : Type u_12
K : Type u_13
K₁ : Type u_14
K₂ : Type u_15
V : Type u_16
V₁ : Type u_17
V₂ : Type u_18
n : Type u_19
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : AddCommGroup M₁
inst✝² : Module R M₁
inst✝¹ : AddCommGroup M₂
inst✝ : Module R M₂
B F : M →ₗ[R] M →ₗ[R] M₂
f : Module.End R M
⊢ f ∈ B.skewAdjointSubmodule ↔ (-B).IsAdjointPair B f f

tactic: exact Iff.rfl
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
Mₗ₁ : Type u_9
Mₗ₁' : Type u_10
Mₗ₂ : Type u_11
Mₗ₂' : Type u_12
K : Type u_13
K₁ : Type u_14
K₂ : Type u_15
V : Type u_16
V₁ : Type u_17
V₂ : Type u_18
n : Type u_19
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : AddCommGroup M₁
inst✝² : Module R M₁
inst✝¹ : AddCommGroup M₂
inst✝ : Module R M₂
B F : M →ₗ[R] M →ₗ[R] M₂
f : Module.End R M
⊢ f ∈ B.skewAdjointSubmodule ↔ (-B).IsAdjointPair B f f
state_after: no goals
Theorem: List.getElem_range
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: simp [range_eq_range']
state_before: n m : Nat
h : m < (range n).length
⊢ (range n)[m] = m
state_after: no goals