1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.imageToKernel_isIso_of_image_eq_kernel
File: Mathlib/Algebra/Homology/Exact.lean

tactic: refine ⟨⟨Subobject.ofLE _ _ p.ge, ?_⟩⟩
state_before: V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasImages V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasKernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
p : imageSubobject f = kernelSubobject g
⊢ IsIso (imageToKernel f g ⋯)
state_after: V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasImages V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasKernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
p : imageSubobject f = kernelSubobject g
⊢ imageToKernel f g ⋯ ≫ (kernelSubobject g).ofLE (imageSubobject f) ⋯ =
      𝟙 (Subobject.underlying.obj (imageSubobject f)) ∧
    (kernelSubobject g).ofLE (imageSubobject f) ⋯ ≫ imageToKernel f g ⋯ =
      𝟙 (Subobject.underlying.obj (kernelSubobject g))

tactic: dsimp [imageToKernel]
state_before: V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasImages V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasKernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
p : imageSubobject f = kernelSubobject g
⊢ imageToKernel f g ⋯ ≫ (kernelSubobject g).ofLE (imageSubobject f) ⋯ =
      𝟙 (Subobject.underlying.obj (imageSubobject f)) ∧
    (kernelSubobject g).ofLE (imageSubobject f) ⋯ ≫ imageToKernel f g ⋯ =
      𝟙 (Subobject.underlying.obj (kernelSubobject g))
state_after: V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasImages V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasKernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
p : imageSubobject f = kernelSubobject g
⊢ (imageSubobject f).ofLE (kernelSubobject g) ⋯ ≫ (kernelSubobject g).ofLE (imageSubobject f) ⋯ =
      𝟙 (Subobject.underlying.obj (imageSubobject f)) ∧
    (kernelSubobject g).ofLE (imageSubobject f) ⋯ ≫ (imageSubobject f).ofLE (kernelSubobject g) ⋯ =
      𝟙 (Subobject.underlying.obj (kernelSubobject g))

tactic: simp only [Subobject.ofLE_comp_ofLE, Subobject.ofLE_refl, and_self]
state_before: V : Type u
inst✝³ : Category.{v, u} V
inst✝² : HasImages V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasKernels V
A B C : V
f : A ⟶ B
g : B ⟶ C
p : imageSubobject f = kernelSubobject g
⊢ (imageSubobject f).ofLE (kernelSubobject g) ⋯ ≫ (kernelSubobject g).ofLE (imageSubobject f) ⋯ =
      𝟙 (Subobject.underlying.obj (imageSubobject f)) ∧
    (kernelSubobject g).ofLE (imageSubobject f) ⋯ ≫ (imageSubobject f).ofLE (kernelSubobject g) ⋯ =
      𝟙 (Subobject.underlying.obj (kernelSubobject g))
state_after: no goals
Theorem: Cardinal.aleph_limit
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: apply le_antisymm _ (ciSup_le' _)
state_before: o : Ordinal.{u_1}
ho : o.IsLimit
⊢ aleph o = ⨆ a, aleph ↑a
state_after: o : Ordinal.{u_1}
ho : o.IsLimit
⊢ aleph o ≤ ⨆ i, aleph ↑i

o : Ordinal.{u_1}
ho : o.IsLimit
⊢ ∀ (i : ↑(Iio o)), aleph ↑i ≤ aleph o

tactic: rw [aleph, aleph'_limit (ho.add _)]
state_before: o : Ordinal.{u_1}
ho : o.IsLimit
⊢ aleph o ≤ ⨆ i, aleph ↑i
state_after: o : Ordinal.{u_1}
ho : o.IsLimit
⊢ ⨆ a, aleph' ↑a ≤ ⨆ i, aleph ↑i

tactic: refine ciSup_mono' (bddAbove_of_small _) ?_
state_before: o : Ordinal.{u_1}
ho : o.IsLimit
⊢ ⨆ a, aleph' ↑a ≤ ⨆ i, aleph ↑i
state_after: o : Ordinal.{u_1}
ho : o.IsLimit
⊢ ∀ (i : ↑(Iio (ω + o))), ∃ i', aleph' ↑i ≤ aleph ↑i'

tactic: rintro ⟨i, hi⟩
state_before: o : Ordinal.{u_1}
ho : o.IsLimit
⊢ ∀ (i : ↑(Iio (ω + o))), ∃ i', aleph' ↑i ≤ aleph ↑i'
state_after: case mk
o : Ordinal.{u_1}
ho : o.IsLimit
i : Ordinal.{u_1}
hi : i ∈ Iio (ω + o)
⊢ ∃ i', aleph' ↑⟨i, hi⟩ ≤ aleph ↑i'

tactic: cases' lt_or_le i ω with h h
state_before: case mk
o : Ordinal.{u_1}
ho : o.IsLimit
i : Ordinal.{u_1}
hi : i ∈ Iio (ω + o)
⊢ ∃ i', aleph' ↑⟨i, hi⟩ ≤ aleph ↑i'
state_after: case mk.inl
o : Ordinal.{u_1}
ho : o.IsLimit
i : Ordinal.{u_1}
hi : i ∈ Iio (ω + o)
h : i < ω
⊢ ∃ i', aleph' ↑⟨i, hi⟩ ≤ aleph ↑i'

case mk.inr
o : Ordinal.{u_1}
ho : o.IsLimit
i : Ordinal.{u_1}
hi : i ∈ Iio (ω + o)
h : ω ≤ i
⊢ ∃ i', aleph' ↑⟨i, hi⟩ ≤ aleph ↑i'

tactic: rcases lt_omega.1 h with ⟨n, rfl⟩
state_before: case mk.inl
o : Ordinal.{u_1}
ho : o.IsLimit
i : Ordinal.{u_1}
hi : i ∈ Iio (ω + o)
h : i < ω
⊢ ∃ i', aleph' ↑⟨i, hi⟩ ≤ aleph ↑i'
state_after: case mk.inl.intro
o : Ordinal.{u_1}
ho : o.IsLimit
n : ℕ
hi : ↑n ∈ Iio (ω + o)
h : ↑n < ω
⊢ ∃ i', aleph' ↑⟨↑n, hi⟩ ≤ aleph ↑i'

tactic: use ⟨0, ho.pos⟩
state_before: case mk.inl.intro
o : Ordinal.{u_1}
ho : o.IsLimit
n : ℕ
hi : ↑n ∈ Iio (ω + o)
h : ↑n < ω
⊢ ∃ i', aleph' ↑⟨↑n, hi⟩ ≤ aleph ↑i'
state_after: case h
o : Ordinal.{u_1}
ho : o.IsLimit
n : ℕ
hi : ↑n ∈ Iio (ω + o)
h : ↑n < ω
⊢ aleph' ↑⟨↑n, hi⟩ ≤ aleph ↑⟨0, ⋯⟩

tactic: simpa using (nat_lt_aleph0 n).le
state_before: case h
o : Ordinal.{u_1}
ho : o.IsLimit
n : ℕ
hi : ↑n ∈ Iio (ω + o)
h : ↑n < ω
⊢ aleph' ↑⟨↑n, hi⟩ ≤ aleph ↑⟨0, ⋯⟩
state_after: no goals

tactic: exact ⟨⟨_, (sub_lt_of_le h).2 hi⟩, aleph'_le.2 (le_add_sub _ _)⟩
state_before: case mk.inr
o : Ordinal.{u_1}
ho : o.IsLimit
i : Ordinal.{u_1}
hi : i ∈ Iio (ω + o)
h : ω ≤ i
⊢ ∃ i', aleph' ↑⟨i, hi⟩ ≤ aleph ↑i'
state_after: no goals

tactic: exact fun i => aleph_le.2 (le_of_lt i.2)
state_before: o : Ordinal.{u_1}
ho : o.IsLimit
⊢ ∀ (i : ↑(Iio o)), aleph ↑i ≤ aleph o
state_after: no goals
Theorem: Real.tendsto_toNNReal_atTop_iff
File: Mathlib/Topology/Instances/NNReal.lean

tactic: rw [← Real.comap_toNNReal_atTop, tendsto_comap_iff, Function.comp_def]
state_before: α : Type u_1
l : Filter α
f : α → ℝ
⊢ Tendsto (fun x => (f x).toNNReal) l atTop ↔ Tendsto f l atTop
state_after: no goals
Theorem: le_div_iff'
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [mul_comm, le_div_iff hc]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hc : 0 < c
⊢ a ≤ b / c ↔ c * a ≤ b
state_after: no goals
Theorem: Real.convergent_of_int
File: Mathlib/NumberTheory/DiophantineApproximation.lean

tactic: cases n
state_before: ξ : ℤ
n : ℕ
⊢ (↑ξ).convergent n = ↑ξ
state_after: case zero
ξ : ℤ
⊢ (↑ξ).convergent 0 = ↑ξ

case succ
ξ : ℤ
n✝ : ℕ
⊢ (↑ξ).convergent (n✝ + 1) = ↑ξ

tactic: simp only [Nat.zero_eq, convergent_zero, floor_intCast]
state_before: case zero
ξ : ℤ
⊢ (↑ξ).convergent 0 = ↑ξ
state_after: no goals

tactic: simp only [convergent_succ, floor_intCast, fract_intCast, convergent_of_zero, add_zero,
  inv_zero]
state_before: case succ
ξ : ℤ
n✝ : ℕ
⊢ (↑ξ).convergent (n✝ + 1) = ↑ξ
state_after: no goals
Theorem: List.filter_attach'
File: Mathlib/Data/List/Basic.lean

tactic: refine map_injective_iff.2 Subtype.coe_injective ?_
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p✝ : α → Bool
l : List α
p : { a // a ∈ l } → Bool
inst✝ : DecidableEq α
⊢ filter p l.attach = map (Subtype.map id ⋯) (filter (fun x => decide (∃ h, p ⟨x, h⟩ = true)) l).attach
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p✝ : α → Bool
l : List α
p : { a // a ∈ l } → Bool
inst✝ : DecidableEq α
⊢ map (fun a => ↑a) (filter p l.attach) =
    map (fun a => ↑a) (map (Subtype.map id ⋯) (filter (fun x => decide (∃ h, p ⟨x, h⟩ = true)) l).attach)
Theorem: AntilipschitzWith.to_rightInvOn'
File: Mathlib/Topology/MetricSpace/Antilipschitz.lean

tactic: simpa only [restrict_apply, g_inv x.mem, g_inv y.mem, Subtype.edist_eq, Subtype.coe_mk] using
  hf ⟨g x, g_maps x.mem⟩ ⟨g y, g_maps y.mem⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f : α → β
s : Set α
hf : AntilipschitzWith K (s.restrict f)
g : β → α
t : Set β
g_maps : MapsTo g t s
g_inv : RightInvOn g f t
x y : ↑t
⊢ edist (t.restrict g x) (t.restrict g y) ≤ ↑K * edist x y
state_after: no goals
Theorem: Ideal.polynomialQuotientEquivQuotientPolynomial_symm_mk
File: Mathlib/RingTheory/Polynomial/Quotient.lean

tactic: rw [polynomialQuotientEquivQuotientPolynomial, RingEquiv.symm_mk, RingEquiv.coe_mk,
  Equiv.coe_fn_mk, Quotient.lift_mk, coe_eval₂RingHom, eval₂_eq_eval_map, ← Polynomial.map_map,
  ← eval₂_eq_eval_map, Polynomial.eval₂_C_X]
state_before: R : Type u_1
inst✝ : CommRing R
I : Ideal R
f : R[X]
⊢ I.polynomialQuotientEquivQuotientPolynomial.symm ((Quotient.mk (map C I)) f) = Polynomial.map (Quotient.mk I) f
state_after: no goals
Theorem: multiplicity.multiplicity_map_eq
File: Mathlib/RingTheory/Multiplicity.lean

tactic: rw [← map_pow]
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : Monoid α
inst✝⁴ : Monoid β
inst✝³ : DecidableRel fun x x_1 => x ∣ x_1
inst✝² : DecidableRel fun x x_1 => x ∣ x_1
F : Type u_3
inst✝¹ : EquivLike F α β
inst✝ : MulEquivClass F α β
f : F
a b : α
n : ℕ
⊢ f a ^ n ∣ f b ↔ a ^ n ∣ b
state_after: α : Type u_1
β : Type u_2
inst✝⁵ : Monoid α
inst✝⁴ : Monoid β
inst✝³ : DecidableRel fun x x_1 => x ∣ x_1
inst✝² : DecidableRel fun x x_1 => x ∣ x_1
F : Type u_3
inst✝¹ : EquivLike F α β
inst✝ : MulEquivClass F α β
f : F
a b : α
n : ℕ
⊢ f (a ^ n) ∣ f b ↔ a ^ n ∣ b

tactic: exact map_dvd_iff f
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : Monoid α
inst✝⁴ : Monoid β
inst✝³ : DecidableRel fun x x_1 => x ∣ x_1
inst✝² : DecidableRel fun x x_1 => x ∣ x_1
F : Type u_3
inst✝¹ : EquivLike F α β
inst✝ : MulEquivClass F α β
f : F
a b : α
n : ℕ
⊢ f (a ^ n) ∣ f b ↔ a ^ n ∣ b
state_after: no goals
Theorem: CauSeq.lt_irrefl
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

tactic: simp [zero_limZero]
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
f : CauSeq α abs
x✝ : f < f
h : f < f := x✝
⊢ (f - f).LimZero
state_after: no goals
Theorem: MeasureTheory.IntegrableOn.inter_of_restrict
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: have := h.mono_set (inter_subset_left (t := t))
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
h : IntegrableOn f s (μ.restrict t)
⊢ IntegrableOn f (s ∩ t) μ
state_after: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
h : IntegrableOn f s (μ.restrict t)
this : IntegrableOn f (s ∩ t) (μ.restrict t)
⊢ IntegrableOn f (s ∩ t) μ

tactic: rwa [IntegrableOn, μ.restrict_restrict_of_subset inter_subset_right] at this
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
h : IntegrableOn f s (μ.restrict t)
this : IntegrableOn f (s ∩ t) (μ.restrict t)
⊢ IntegrableOn f (s ∩ t) μ
state_after: no goals
Theorem: QuadraticForm.map_neg
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: rw [← @neg_one_smul R _ _ _ _ x, map_smul, neg_one_mul, neg_neg, one_mul]
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
x : M
⊢ Q (-x) = Q x
state_after: no goals
Theorem: UniqueFactorizationMonoid.exists_mem_factors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: obtain ⟨p', hp', hp'x⟩ := WfDvdMonoid.exists_irreducible_factor h hx
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
x : α
hx : x ≠ 0
h : ¬IsUnit x
⊢ ∃ p, p ∈ factors x
state_after: case intro.intro
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
x : α
hx : x ≠ 0
h : ¬IsUnit x
p' : α
hp' : Irreducible p'
hp'x : p' ∣ x
⊢ ∃ p, p ∈ factors x

tactic: obtain ⟨p, hp, _⟩ := exists_mem_factors_of_dvd hx hp' hp'x
state_before: case intro.intro
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
x : α
hx : x ≠ 0
h : ¬IsUnit x
p' : α
hp' : Irreducible p'
hp'x : p' ∣ x
⊢ ∃ p, p ∈ factors x
state_after: case intro.intro.intro.intro
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
x : α
hx : x ≠ 0
h : ¬IsUnit x
p' : α
hp' : Irreducible p'
hp'x : p' ∣ x
p : α
hp : p ∈ factors x
right✝ : p' ~ᵤ p
⊢ ∃ p, p ∈ factors x

tactic: exact ⟨p, hp⟩
state_before: case intro.intro.intro.intro
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
x : α
hx : x ≠ 0
h : ¬IsUnit x
p' : α
hp' : Irreducible p'
hp'x : p' ∣ x
p : α
hp : p ∈ factors x
right✝ : p' ~ᵤ p
⊢ ∃ p, p ∈ factors x
state_after: no goals
Theorem: MeasureTheory.Submartingale.upcrossings_ae_lt_top
File: Mathlib/Probability/Martingale/Convergence.lean

tactic: simp only [ae_all_iff, eventually_imp_distrib_left]
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
a b : ℝ
f : ℕ → Ω → ℝ
ω : Ω
R : ℝ≥0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
hbdd : ∀ (n : ℕ), snorm (f n) 1 μ ≤ ↑R
⊢ ∀ᵐ (ω : Ω) ∂μ, ∀ (a b : ℚ), a < b → upcrossings (↑a) (↑b) f ω < ⊤
state_after: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
a b : ℝ
f : ℕ → Ω → ℝ
ω : Ω
R : ℝ≥0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
hbdd : ∀ (n : ℕ), snorm (f n) 1 μ ≤ ↑R
⊢ ∀ (i i_1 : ℚ), i < i_1 → ∀ᵐ (x : Ω) ∂μ, upcrossings (↑i) (↑i_1) f x < ⊤

tactic: rintro a b hab
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
a b : ℝ
f : ℕ → Ω → ℝ
ω : Ω
R : ℝ≥0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
hbdd : ∀ (n : ℕ), snorm (f n) 1 μ ≤ ↑R
⊢ ∀ (i i_1 : ℚ), i < i_1 → ∀ᵐ (x : Ω) ∂μ, upcrossings (↑i) (↑i_1) f x < ⊤
state_after: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
a✝ b✝ : ℝ
f : ℕ → Ω → ℝ
ω : Ω
R : ℝ≥0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
hbdd : ∀ (n : ℕ), snorm (f n) 1 μ ≤ ↑R
a b : ℚ
hab : a < b
⊢ ∀ᵐ (x : Ω) ∂μ, upcrossings (↑a) (↑b) f x < ⊤

tactic: exact hf.upcrossings_ae_lt_top' hbdd (Rat.cast_lt.2 hab)
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
ℱ : Filtration ℕ m0
a✝ b✝ : ℝ
f : ℕ → Ω → ℝ
ω : Ω
R : ℝ≥0
inst✝ : IsFiniteMeasure μ
hf : Submartingale f ℱ μ
hbdd : ∀ (n : ℕ), snorm (f n) 1 μ ≤ ↑R
a b : ℚ
hab : a < b
⊢ ∀ᵐ (x : Ω) ∂μ, upcrossings (↑a) (↑b) f x < ⊤
state_after: no goals
Theorem: Real.surjOn_log'
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rw [log_neg_eq_log, log_exp]
state_before: x✝¹ y x : ℝ
x✝ : x ∈ univ
⊢ log (-rexp x) = x
state_after: no goals
Theorem: LSeries_neg
File: Mathlib/NumberTheory/LSeries/Linearity.lean

tactic: simp only [LSeries, term_neg_apply, tsum_neg]
state_before: f : ℕ → ℂ
s : ℂ
⊢ LSeries (-f) s = -LSeries f s
state_after: no goals
Theorem: Ideal.pow_mem_of_pow_mem
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: rw [← Nat.add_sub_of_le h, pow_add]
state_before: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
I : Ideal α
m n : ℕ
ha : a ^ m ∈ I
h : m ≤ n
⊢ a ^ n ∈ I
state_after: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
I : Ideal α
m n : ℕ
ha : a ^ m ∈ I
h : m ≤ n
⊢ a ^ m * a ^ (n - m) ∈ I

tactic: exact I.mul_mem_right _ ha
state_before: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
I : Ideal α
m n : ℕ
ha : a ^ m ∈ I
h : m ≤ n
⊢ a ^ m * a ^ (n - m) ∈ I
state_after: no goals
Theorem: toDFinsupp_support
File: Mathlib/Data/Finsupp/ToDFinsupp.lean

tactic: ext
state_before: ι : Type u_1
R : Type u_2
M : Type u_3
inst✝² : DecidableEq ι
inst✝¹ : Zero M
inst✝ : (m : M) → Decidable (m ≠ 0)
f : ι →₀ M
⊢ f.toDFinsupp.support = f.support
state_after: case a
ι : Type u_1
R : Type u_2
M : Type u_3
inst✝² : DecidableEq ι
inst✝¹ : Zero M
inst✝ : (m : M) → Decidable (m ≠ 0)
f : ι →₀ M
a✝ : ι
⊢ a✝ ∈ f.toDFinsupp.support ↔ a✝ ∈ f.support

tactic: simp
state_before: case a
ι : Type u_1
R : Type u_2
M : Type u_3
inst✝² : DecidableEq ι
inst✝¹ : Zero M
inst✝ : (m : M) → Decidable (m ≠ 0)
f : ι →₀ M
a✝ : ι
⊢ a✝ ∈ f.toDFinsupp.support ↔ a✝ ∈ f.support
state_after: no goals
Theorem: Matrix.rank_vecMulVec
File: Mathlib/LinearAlgebra/FreeModule/Finite/Matrix.lean

tactic: nontriviality K
state_before: R : Type u
S : Type u'
M : Type v
N : Type w
K m n : Type u
inst✝² : CommRing K
inst✝¹ : Fintype n
inst✝ : DecidableEq n
w : m → K
v : n → K
⊢ (toLin' (vecMulVec w v)).rank ≤ 1
state_after: R : Type u
S : Type u'
M : Type v
N : Type w
K m n : Type u
inst✝² : CommRing K
inst✝¹ : Fintype n
inst✝ : DecidableEq n
w : m → K
v : n → K
a✝ : Nontrivial K
⊢ (toLin' (vecMulVec w v)).rank ≤ 1

tactic: rw [Matrix.vecMulVec_eq (Fin 1), Matrix.toLin'_mul]
state_before: R : Type u
S : Type u'
M : Type v
N : Type w
K m n : Type u
inst✝² : CommRing K
inst✝¹ : Fintype n
inst✝ : DecidableEq n
w : m → K
v : n → K
a✝ : Nontrivial K
⊢ (toLin' (vecMulVec w v)).rank ≤ 1
state_after: R : Type u
S : Type u'
M : Type v
N : Type w
K m n : Type u
inst✝² : CommRing K
inst✝¹ : Fintype n
inst✝ : DecidableEq n
w : m → K
v : n → K
a✝ : Nontrivial K
⊢ (toLin' (col (Fin 1) w) ∘ₗ toLin' (row (Fin 1) v)).rank ≤ 1

tactic: refine le_trans (LinearMap.rank_comp_le_left _ _) ?_
state_before: R : Type u
S : Type u'
M : Type v
N : Type w
K m n : Type u
inst✝² : CommRing K
inst✝¹ : Fintype n
inst✝ : DecidableEq n
w : m → K
v : n → K
a✝ : Nontrivial K
⊢ (toLin' (col (Fin 1) w) ∘ₗ toLin' (row (Fin 1) v)).rank ≤ 1
state_after: R : Type u
S : Type u'
M : Type v
N : Type w
K m n : Type u
inst✝² : CommRing K
inst✝¹ : Fintype n
inst✝ : DecidableEq n
w : m → K
v : n → K
a✝ : Nontrivial K
⊢ (toLin' (col (Fin 1) w)).rank ≤ 1

tactic: refine (LinearMap.rank_le_domain _).trans_eq ?_
state_before: R : Type u
S : Type u'
M : Type v
N : Type w
K m n : Type u
inst✝² : CommRing K
inst✝¹ : Fintype n
inst✝ : DecidableEq n
w : m → K
v : n → K
a✝ : Nontrivial K
⊢ (toLin' (col (Fin 1) w)).rank ≤ 1
state_after: R : Type u
S : Type u'
M : Type v
N : Type w
K m n : Type u
inst✝² : CommRing K
inst✝¹ : Fintype n
inst✝ : DecidableEq n
w : m → K
v : n → K
a✝ : Nontrivial K
⊢ Module.rank K (Fin 1 → K) = 1

tactic: rw [rank_fun', Fintype.card_ofSubsingleton, Nat.cast_one]
state_before: R : Type u
S : Type u'
M : Type v
N : Type w
K m n : Type u
inst✝² : CommRing K
inst✝¹ : Fintype n
inst✝ : DecidableEq n
w : m → K
v : n → K
a✝ : Nontrivial K
⊢ Module.rank K (Fin 1 → K) = 1
state_after: no goals
Theorem: Nat.Ico_succ_right
File: Mathlib/Order/Interval/Finset/Nat.lean

tactic: ext x
state_before: a b c : ℕ
⊢ Ico a b.succ = Icc a b
state_after: case a
a b c x : ℕ
⊢ x ∈ Ico a b.succ ↔ x ∈ Icc a b

tactic: rw [mem_Ico, mem_Icc, Nat.lt_succ_iff]
state_before: case a
a b c x : ℕ
⊢ x ∈ Ico a b.succ ↔ x ∈ Icc a b
state_after: no goals
Theorem: Int.lcm_assoc
File: Mathlib/Data/Int/GCD.lean

tactic: rw [Int.lcm, Int.lcm, Int.lcm, Int.lcm, natAbs_ofNat, natAbs_ofNat]
state_before: i j k : ℤ
⊢ (↑(i.lcm j)).lcm k = i.lcm ↑(j.lcm k)
state_after: i j k : ℤ
⊢ (i.natAbs.lcm j.natAbs).lcm k.natAbs = i.natAbs.lcm (j.natAbs.lcm k.natAbs)

tactic: apply Nat.lcm_assoc
state_before: i j k : ℤ
⊢ (i.natAbs.lcm j.natAbs).lcm k.natAbs = i.natAbs.lcm (j.natAbs.lcm k.natAbs)
state_after: no goals
Theorem: Pi.toLex_monotone
File: Mathlib/Order/PiLex.lean

tactic: contrapose! hl
state_before: ι : Type u_1
β : ι → Type u_2
r : ι → ι → Prop
s : {i : ι} → β i → β i → Prop
inst✝² : LinearOrder ι
inst✝¹ : IsWellOrder ι fun x x_1 => x < x_1
inst✝ : (i : ι) → PartialOrder (β i)
x y : (i : ι) → β i
i✝ : ι
a✝ : β i✝
a b : (i : ι) → β i
h : a ≤ b
hne : ¬toLex a = toLex b
i : ι
hi : i ∈ {i | a i ≠ b i}
hl : ∀ x ∈ {i | a i ≠ b i}, ¬x < i
j : ι
hj : (fun x x_1 => x < x_1) j i
⊢ toLex a j = toLex b j
state_after: ι : Type u_1
β : ι → Type u_2
r : ι → ι → Prop
s : {i : ι} → β i → β i → Prop
inst✝² : LinearOrder ι
inst✝¹ : IsWellOrder ι fun x x_1 => x < x_1
inst✝ : (i : ι) → PartialOrder (β i)
x y : (i : ι) → β i
i✝ : ι
a✝ : β i✝
a b : (i : ι) → β i
h : a ≤ b
hne : ¬toLex a = toLex b
i : ι
hi : i ∈ {i | a i ≠ b i}
j : ι
hj : (fun x x_1 => x < x_1) j i
hl : toLex a j ≠ toLex b j
⊢ ∃ x ∈ {i | a i ≠ b i}, x < i

tactic: exact ⟨j, hl, hj⟩
state_before: ι : Type u_1
β : ι → Type u_2
r : ι → ι → Prop
s : {i : ι} → β i → β i → Prop
inst✝² : LinearOrder ι
inst✝¹ : IsWellOrder ι fun x x_1 => x < x_1
inst✝ : (i : ι) → PartialOrder (β i)
x y : (i : ι) → β i
i✝ : ι
a✝ : β i✝
a b : (i : ι) → β i
h : a ≤ b
hne : ¬toLex a = toLex b
i : ι
hi : i ∈ {i | a i ≠ b i}
j : ι
hj : (fun x x_1 => x < x_1) j i
hl : toLex a j ≠ toLex b j
⊢ ∃ x ∈ {i | a i ≠ b i}, x < i
state_after: no goals
Theorem: isSeparatedMap_iff_closedEmbedding
File: Mathlib/Topology/SeparatedMap.lean

tactic: rw [isSeparatedMap_iff_isClosed_diagonal, ← range_toPullbackDiag]
state_before: X : Type u_1
Y : Sort u_2
A : Type ?u.10539
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace A
f : X → Y
⊢ IsSeparatedMap f ↔ ClosedEmbedding (toPullbackDiag f)
state_after: X : Type u_1
Y : Sort u_2
A : Type ?u.10539
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace A
f : X → Y
⊢ IsClosed (Set.range (toPullbackDiag f)) ↔ ClosedEmbedding (toPullbackDiag f)

tactic: exact ⟨fun h ↦ ⟨embedding_toPullbackDiag f, h⟩, fun h ↦ h.isClosed_range⟩
state_before: X : Type u_1
Y : Sort u_2
A : Type ?u.10539
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace A
f : X → Y
⊢ IsClosed (Set.range (toPullbackDiag f)) ↔ ClosedEmbedding (toPullbackDiag f)
state_after: no goals
Theorem: MeasureTheory.snorm'_measure_zero_of_neg
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

tactic: simp [snorm', hq_neg]
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
inst✝ : MeasurableSpace α
f : α → F
hq_neg : q < 0
⊢ snorm' f q 0 = ⊤
state_after: no goals
Theorem: SimpleGraph.Iso.connectedComponentEquiv_symm
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: ext ⟨_⟩
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
φ : G ≃g G'
⊢ φ.symm.connectedComponentEquiv = φ.connectedComponentEquiv.symm
state_after: case H.mk
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
φ : G ≃g G'
x✝ : G'.ConnectedComponent
a✝ : V'
⊢ φ.symm.connectedComponentEquiv (Quot.mk G'.Reachable a✝) = φ.connectedComponentEquiv.symm (Quot.mk G'.Reachable a✝)

tactic: rfl
state_before: case H.mk
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
φ : G ≃g G'
x✝ : G'.ConnectedComponent
a✝ : V'
⊢ φ.symm.connectedComponentEquiv (Quot.mk G'.Reachable a✝) = φ.connectedComponentEquiv.symm (Quot.mk G'.Reachable a✝)
state_after: no goals
Theorem: Finset.disjoint_singleton_left
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [disjoint_left, mem_singleton, forall_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
s t u : Finset α
a b : α
⊢ _root_.Disjoint {a} s ↔ a ∉ s
state_after: no goals
Theorem: Nat.frequently_odd
File: Mathlib/Order/Filter/ModEq.lean

tactic: simpa only [odd_iff] using frequently_mod_eq one_lt_two
state_before: ⊢ ∃ᶠ (m : ℕ) in atTop, Odd m
state_after: no goals
Theorem: MeasureTheory.AEEqFun.coeFn_compQuasiMeasurePreserving
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: rw [compQuasiMeasurePreserving_eq_mk]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : MeasurableSpace α
μ ν✝ : Measure α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : MeasurableSpace β
ν : Measure β
f : α → β
g : β →ₘ[ν] γ
hf : QuasiMeasurePreserving f μ ν
⊢ ↑(g.compQuasiMeasurePreserving f hf) =ᶠ[ae μ] ↑g ∘ f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : MeasurableSpace α
μ ν✝ : Measure α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : MeasurableSpace β
ν : Measure β
f : α → β
g : β →ₘ[ν] γ
hf : QuasiMeasurePreserving f μ ν
⊢ ↑(mk (↑g ∘ f) ⋯) =ᶠ[ae μ] ↑g ∘ f

tactic: apply coeFn_mk
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : MeasurableSpace α
μ ν✝ : Measure α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : MeasurableSpace β
ν : Measure β
f : α → β
g : β →ₘ[ν] γ
hf : QuasiMeasurePreserving f μ ν
⊢ ↑(mk (↑g ∘ f) ⋯) =ᶠ[ae μ] ↑g ∘ f
state_after: no goals
Theorem: inf_sdiff_self_left
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [inf_comm, inf_sdiff_self_right]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ y \ x ⊓ x = ⊥
state_after: no goals