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

tactic: let ⟨g, hg⟩ := factor_dvd_of_natDegree_ne_zero hf
state_before: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
f : K[X]
hf : f.natDegree ≠ 0
⊢ (X - C (AdjoinRoot.root f.factor)) * f.removeFactor = map (AdjoinRoot.of f.factor) f
state_after: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
f : K[X]
hf : f.natDegree ≠ 0
g : K[X]
hg : f = f.factor * g
⊢ (X - C (AdjoinRoot.root f.factor)) * f.removeFactor = map (AdjoinRoot.of f.factor) f

tactic: apply (mul_divByMonic_eq_iff_isRoot
  (R := AdjoinRoot f.factor) (a := AdjoinRoot.root f.factor)).mpr
state_before: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
f : K[X]
hf : f.natDegree ≠ 0
g : K[X]
hg : f = f.factor * g
⊢ (X - C (AdjoinRoot.root f.factor)) * f.removeFactor = map (AdjoinRoot.of f.factor) f
state_after: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
f : K[X]
hf : f.natDegree ≠ 0
g : K[X]
hg : f = f.factor * g
⊢ (map (AdjoinRoot.of f.factor) f).IsRoot (AdjoinRoot.root f.factor)

tactic: rw [IsRoot.def, eval_map, hg, eval₂_mul, ← hg, AdjoinRoot.eval₂_root, zero_mul]
state_before: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
f : K[X]
hf : f.natDegree ≠ 0
g : K[X]
hg : f = f.factor * g
⊢ (map (AdjoinRoot.of f.factor) f).IsRoot (AdjoinRoot.root f.factor)
state_after: no goals
Theorem: Polynomial.map_injective
File: Mathlib/Algebra/Polynomial/Eval.lean

tactic: rw [← coeff_map f, ← coeff_map f, h]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m✝ n : ℕ
inst✝¹ : Semiring R
p✝ q✝ r : R[X]
inst✝ : Semiring S
f : R →+* S
hf : Function.Injective ⇑f
p q : R[X]
h : map f p = map f q
m : ℕ
⊢ f (p.coeff m) = f (q.coeff m)
state_after: no goals
Theorem: Basis.toLin_toMatrix
File: Mathlib/LinearAlgebra/Matrix/Basis.lean

tactic: cases nonempty_fintype ι
state_before: ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
R : Type u_5
M : Type u_6
inst✝⁸ : CommSemiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
R₂ : Type u_7
M₂ : Type u_8
inst✝⁵ : CommRing R₂
inst✝⁴ : AddCommGroup M₂
inst✝³ : Module R₂ M₂
e : Basis ι R M
v✝ : ι' → M
i✝ : ι
j : ι'
inst✝² : Finite ι
inst✝¹ : Fintype ι'
inst✝ : DecidableEq ι'
v : Basis ι' R M
i : ι'
⊢ ((toLin v e) (e.toMatrix ⇑v)) (v i) = LinearMap.id (v i)
state_after: case intro
ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
R : Type u_5
M : Type u_6
inst✝⁸ : CommSemiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
R₂ : Type u_7
M₂ : Type u_8
inst✝⁵ : CommRing R₂
inst✝⁴ : AddCommGroup M₂
inst✝³ : Module R₂ M₂
e : Basis ι R M
v✝ : ι' → M
i✝ : ι
j : ι'
inst✝² : Finite ι
inst✝¹ : Fintype ι'
inst✝ : DecidableEq ι'
v : Basis ι' R M
i : ι'
val✝ : Fintype ι
⊢ ((toLin v e) (e.toMatrix ⇑v)) (v i) = LinearMap.id (v i)

tactic: rw [toLin_self, id_apply, e.sum_toMatrix_smul_self]
state_before: case intro
ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
R : Type u_5
M : Type u_6
inst✝⁸ : CommSemiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
R₂ : Type u_7
M₂ : Type u_8
inst✝⁵ : CommRing R₂
inst✝⁴ : AddCommGroup M₂
inst✝³ : Module R₂ M₂
e : Basis ι R M
v✝ : ι' → M
i✝ : ι
j : ι'
inst✝² : Finite ι
inst✝¹ : Fintype ι'
inst✝ : DecidableEq ι'
v : Basis ι' R M
i : ι'
val✝ : Fintype ι
⊢ ((toLin v e) (e.toMatrix ⇑v)) (v i) = LinearMap.id (v i)
state_after: no goals
Theorem: Set.ite_empty
File: Mathlib/Data/Set/Basic.lean

tactic: simp [Set.ite]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s s' : Set α
⊢ ∅.ite s s' = s'
state_after: no goals
Theorem: DirectSum.sum_univ_of
File: Mathlib/Algebra/DirectSum/Basic.lean

tactic: apply DFinsupp.ext (fun i ↦ ?_)
state_before: ι : Type v
dec_ι : DecidableEq ι
β : ι → Type w
inst✝¹ : (i : ι) → AddCommMonoid (β i)
inst✝ : Fintype ι
x : ⨁ (i : ι), β i
⊢ ∑ i : ι, (of β i) (x i) = x
state_after: ι : Type v
dec_ι : DecidableEq ι
β : ι → Type w
inst✝¹ : (i : ι) → AddCommMonoid (β i)
inst✝ : Fintype ι
x : ⨁ (i : ι), β i
i : ι
⊢ (∑ i : ι, (of β i) (x i)) i = x i

tactic: rw [DFinsupp.finset_sum_apply]
state_before: ι : Type v
dec_ι : DecidableEq ι
β : ι → Type w
inst✝¹ : (i : ι) → AddCommMonoid (β i)
inst✝ : Fintype ι
x : ⨁ (i : ι), β i
i : ι
⊢ (∑ i : ι, (of β i) (x i)) i = x i
state_after: ι : Type v
dec_ι : DecidableEq ι
β : ι → Type w
inst✝¹ : (i : ι) → AddCommMonoid (β i)
inst✝ : Fintype ι
x : ⨁ (i : ι), β i
i : ι
⊢ ∑ a : ι, ((of β a) (x a)) i = x i

tactic: simp [of_apply]
state_before: ι : Type v
dec_ι : DecidableEq ι
β : ι → Type w
inst✝¹ : (i : ι) → AddCommMonoid (β i)
inst✝ : Fintype ι
x : ⨁ (i : ι), β i
i : ι
⊢ ∑ a : ι, ((of β a) (x a)) i = x i
state_after: no goals
Theorem: sum_div_card_sq_le_sum_sq_div_card
File: Mathlib/Algebra/Order/Chebyshev.lean

tactic: obtain rfl | hs := s.eq_empty_or_nonempty
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
s : Finset ι
f : ι → α
⊢ ((∑ i ∈ s, f i) / ↑s.card) ^ 2 ≤ (∑ i ∈ s, f i ^ 2) / ↑s.card
state_after: case inl
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
f : ι → α
⊢ ((∑ i ∈ ∅, f i) / ↑∅.card) ^ 2 ≤ (∑ i ∈ ∅, f i ^ 2) / ↑∅.card

case inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
s : Finset ι
f : ι → α
hs : s.Nonempty
⊢ ((∑ i ∈ s, f i) / ↑s.card) ^ 2 ≤ (∑ i ∈ s, f i ^ 2) / ↑s.card

tactic: rw [← card_pos, ← @Nat.cast_pos α] at hs
state_before: case inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
s : Finset ι
f : ι → α
hs : s.Nonempty
⊢ ((∑ i ∈ s, f i) / ↑s.card) ^ 2 ≤ (∑ i ∈ s, f i ^ 2) / ↑s.card
state_after: case inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
s : Finset ι
f : ι → α
hs : 0 < ↑s.card
⊢ ((∑ i ∈ s, f i) / ↑s.card) ^ 2 ≤ (∑ i ∈ s, f i ^ 2) / ↑s.card

tactic: rw [div_pow, div_le_div_iff (sq_pos_of_ne_zero hs.ne') hs, sq (s.card : α), mul_left_comm, ←
  mul_assoc]
state_before: case inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
s : Finset ι
f : ι → α
hs : 0 < ↑s.card
⊢ ((∑ i ∈ s, f i) / ↑s.card) ^ 2 ≤ (∑ i ∈ s, f i ^ 2) / ↑s.card
state_after: case inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
s : Finset ι
f : ι → α
hs : 0 < ↑s.card
⊢ (∑ i ∈ s, f i) ^ 2 * ↑s.card ≤ (↑s.card * ∑ i ∈ s, f i ^ 2) * ↑s.card

tactic: exact mul_le_mul_of_nonneg_right sq_sum_le_card_mul_sum_sq hs.le
state_before: case inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
s : Finset ι
f : ι → α
hs : 0 < ↑s.card
⊢ (∑ i ∈ s, f i) ^ 2 * ↑s.card ≤ (↑s.card * ∑ i ∈ s, f i ^ 2) * ↑s.card
state_after: no goals

tactic: simp
state_before: case inl
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
f : ι → α
⊢ ((∑ i ∈ ∅, f i) / ↑∅.card) ^ 2 ≤ (∑ i ∈ ∅, f i ^ 2) / ↑∅.card
state_after: no goals
Theorem: MeasureTheory.exists_pair_mem_lattice_not_disjoint_vadd
File: Mathlib/MeasureTheory/Group/GeometryOfNumbers.lean

tactic: contrapose! h
state_before: E : Type u_1
L : Type u_2
inst✝⁶ : MeasurableSpace E
μ : Measure E
F s : Set E
inst✝⁵ : AddCommGroup L
inst✝⁴ : Countable L
inst✝³ : AddAction L E
inst✝² : MeasurableSpace L
inst✝¹ : MeasurableVAdd L E
inst✝ : VAddInvariantMeasure L E μ
fund : IsAddFundamentalDomain L F μ
hS : NullMeasurableSet s μ
h : μ F < μ s
⊢ ∃ x y, x ≠ y ∧ ¬Disjoint (x +ᵥ s) (y +ᵥ s)
state_after: E : Type u_1
L : Type u_2
inst✝⁶ : MeasurableSpace E
μ : Measure E
F s : Set E
inst✝⁵ : AddCommGroup L
inst✝⁴ : Countable L
inst✝³ : AddAction L E
inst✝² : MeasurableSpace L
inst✝¹ : MeasurableVAdd L E
inst✝ : VAddInvariantMeasure L E μ
fund : IsAddFundamentalDomain L F μ
hS : NullMeasurableSet s μ
h : ∀ (x y : L), x ≠ y → Disjoint (x +ᵥ s) (y +ᵥ s)
⊢ μ s ≤ μ F

tactic: exact ((fund.measure_eq_tsum _).trans (measure_iUnion₀
  (Pairwise.mono h fun i j hij => (hij.mono inf_le_left inf_le_left).aedisjoint)
    fun _ => (hS.vadd _).inter fund.nullMeasurableSet).symm).trans_le
    (measure_mono <| Set.iUnion_subset fun _ => Set.inter_subset_right)
state_before: E : Type u_1
L : Type u_2
inst✝⁶ : MeasurableSpace E
μ : Measure E
F s : Set E
inst✝⁵ : AddCommGroup L
inst✝⁴ : Countable L
inst✝³ : AddAction L E
inst✝² : MeasurableSpace L
inst✝¹ : MeasurableVAdd L E
inst✝ : VAddInvariantMeasure L E μ
fund : IsAddFundamentalDomain L F μ
hS : NullMeasurableSet s μ
h : ∀ (x y : L), x ≠ y → Disjoint (x +ᵥ s) (y +ᵥ s)
⊢ μ s ≤ μ F
state_after: no goals
Theorem: PrimeSpectrum.zeroLocus_minimalPrimes
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: rw [← vanishingIdeal_irreducibleComponents, ← Set.image_comp, Set.EqOn.image_eq_self]
state_before: R : Type u
S : Type v
inst✝ : CommSemiring R
⊢ zeroLocus ∘ SetLike.coe '' minimalPrimes R = irreducibleComponents (PrimeSpectrum R)
state_after: R : Type u
S : Type v
inst✝ : CommSemiring R
⊢ Set.EqOn ((zeroLocus ∘ SetLike.coe) ∘ vanishingIdeal) id (irreducibleComponents (PrimeSpectrum R))

tactic: intros s hs
state_before: R : Type u
S : Type v
inst✝ : CommSemiring R
⊢ Set.EqOn ((zeroLocus ∘ SetLike.coe) ∘ vanishingIdeal) id (irreducibleComponents (PrimeSpectrum R))
state_after: R : Type u
S : Type v
inst✝ : CommSemiring R
s : Set (PrimeSpectrum R)
hs : s ∈ irreducibleComponents (PrimeSpectrum R)
⊢ ((zeroLocus ∘ SetLike.coe) ∘ vanishingIdeal) s = id s

tactic: simpa [zeroLocus_vanishingIdeal_eq_closure, closure_eq_iff_isClosed]
  using isClosed_of_mem_irreducibleComponents s hs
state_before: R : Type u
S : Type v
inst✝ : CommSemiring R
s : Set (PrimeSpectrum R)
hs : s ∈ irreducibleComponents (PrimeSpectrum R)
⊢ ((zeroLocus ∘ SetLike.coe) ∘ vanishingIdeal) s = id s
state_after: no goals
Theorem: IsLinearMap.isLinearMap_add
File: Mathlib/Algebra/Module/LinearMap/Prod.lean

tactic: apply IsLinearMap.mk
state_before: R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
⊢ IsLinearMap R fun x => x.1 + x.2
state_after: case map_add
R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
⊢ ∀ (x y : M × M), (x + y).1 + (x + y).2 = x.1 + x.2 + (y.1 + y.2)

case map_smul
R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
⊢ ∀ (c : R) (x : M × M), (c • x).1 + (c • x).2 = c • (x.1 + x.2)

tactic: intro x y
state_before: case map_add
R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
⊢ ∀ (x y : M × M), (x + y).1 + (x + y).2 = x.1 + x.2 + (y.1 + y.2)
state_after: case map_add
R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x y : M × M
⊢ (x + y).1 + (x + y).2 = x.1 + x.2 + (y.1 + y.2)

tactic: simp only [Prod.fst_add, Prod.snd_add]
state_before: case map_add
R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x y : M × M
⊢ (x + y).1 + (x + y).2 = x.1 + x.2 + (y.1 + y.2)
state_after: case map_add
R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x y : M × M
⊢ x.1 + y.1 + (x.2 + y.2) = x.1 + x.2 + (y.1 + y.2)

tactic: abel
state_before: case map_add
R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x y : M × M
⊢ x.1 + y.1 + (x.2 + y.2) = x.1 + x.2 + (y.1 + y.2)
state_after: no goals

tactic: intro x y
state_before: case map_smul
R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
⊢ ∀ (c : R) (x : M × M), (c • x).1 + (c • x).2 = c • (x.1 + x.2)
state_after: case map_smul
R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x : R
y : M × M
⊢ (x • y).1 + (x • y).2 = x • (y.1 + y.2)

tactic: simp [smul_add]
state_before: case map_smul
R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x : R
y : M × M
⊢ (x • y).1 + (x • y).2 = x • (y.1 + y.2)
state_after: no goals
Theorem: ProbabilityTheory.condCDF_eq_stieltjesOfMeasurableRat_unit_prod
File: Mathlib/Probability/Kernel/Disintegration/CondCdf.lean

tactic: ext x
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
⊢ condCDF ρ a = stieltjesOfMeasurableRat (fun p r => (preCDF ρ r p.2).toReal) ⋯ ((), a)
state_after: case h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
x : ℝ
⊢ ↑(condCDF ρ a) x = ↑(stieltjesOfMeasurableRat (fun p r => (preCDF ρ r p.2).toReal) ⋯ ((), a)) x

tactic: rw [condCDF, ← stieltjesOfMeasurableRat_unit_prod]
state_before: case h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
a : α
x : ℝ
⊢ ↑(condCDF ρ a) x = ↑(stieltjesOfMeasurableRat (fun p r => (preCDF ρ r p.2).toReal) ⋯ ((), a)) x
state_after: no goals
Theorem: Set.restrict_extend_range
File: Mathlib/Data/Set/Function.lean

tactic: classical
exact restrict_dite _ _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
f : α → β
g : α → γ
g' : β → γ
⊢ (range f).restrict (extend f g g') = fun x => g (Exists.choose ⋯)
state_after: no goals

tactic: exact restrict_dite _ _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
f : α → β
g : α → γ
g' : β → γ
⊢ (range f).restrict (extend f g g') = fun x => g (Exists.choose ⋯)
state_after: no goals
Theorem: List.TProd.elim_of_mem
File: Mathlib/Data/Prod/TProd.lean

tactic: apply elim_of_ne
state_before: ι : Type u
α : ι → Type v
i j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
hl : (i :: l).Nodup
hj : j ∈ l
v : TProd α (i :: l)
⊢ v.elim ⋯ = TProd.elim v.2 hj
state_after: case hji
ι : Type u
α : ι → Type v
i j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
hl : (i :: l).Nodup
hj : j ∈ l
v : TProd α (i :: l)
⊢ j ≠ i

tactic: rintro rfl
state_before: case hji
ι : Type u
α : ι → Type v
i j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
hl : (i :: l).Nodup
hj : j ∈ l
v : TProd α (i :: l)
⊢ j ≠ i
state_after: case hji
ι : Type u
α : ι → Type v
j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
hj : j ∈ l
hl : (j :: l).Nodup
v : TProd α (j :: l)
⊢ False

tactic: exact hl.not_mem hj
state_before: case hji
ι : Type u
α : ι → Type v
j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
hj : j ∈ l
hl : (j :: l).Nodup
v : TProd α (j :: l)
⊢ False
state_after: no goals
Theorem: WithTop.coe_lt_coe
File: Mathlib/Order/WithBot.lean

tactic: simp only [← toDual_lt_toDual_iff, toDual_apply_coe, WithBot.coe_lt_coe, toDual_lt_toDual]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : LT α
a b : α
⊢ ↑a < ↑b ↔ a < b
state_after: no goals
Theorem: MulLECancellable.le_mul_iff_one_le_right
File: Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean

tactic: rw [mul_one]
state_before: α : Type u_1
β : Type u_2
inst✝² : LE α
inst✝¹ : MulOneClass α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
ha : MulLECancellable a
⊢ a ≤ a * b ↔ a * 1 ≤ a * b
state_after: no goals
Theorem: Ordinal.omega_isLimit
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: let ⟨n, e⟩ := lt_omega.1 h
state_before: o : Ordinal.{u_1}
h : o < ω
⊢ succ o < ω
state_after: o : Ordinal.{u_1}
h : o < ω
n : ℕ
e : o = ↑n
⊢ succ o < ω

tactic: rw [e]
state_before: o : Ordinal.{u_1}
h : o < ω
n : ℕ
e : o = ↑n
⊢ succ o < ω
state_after: o : Ordinal.{u_1}
h : o < ω
n : ℕ
e : o = ↑n
⊢ succ ↑n < ω

tactic: exact nat_lt_omega (n + 1)
state_before: o : Ordinal.{u_1}
h : o < ω
n : ℕ
e : o = ↑n
⊢ succ ↑n < ω
state_after: no goals
Theorem: CategoryTheory.Bicategory.associator_naturality_left
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f f' : a ⟶ b
η : f ⟶ f'
g : b ⟶ c
h : c ⟶ d
⊢ η ▷ g ▷ h ≫ (α_ f' g h).hom = (α_ f g h).hom ≫ η ▷ (g ≫ h)
state_after: no goals
Theorem: Filter.comap_snd_neBot_iff
File: Mathlib/Order/Filter/Basic.lean

tactic: cases' isEmpty_or_nonempty α with hα hα
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
⊢ (comap Prod.snd f).NeBot ↔ Nonempty α ∧ f.NeBot
state_after: case inl
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
hα : IsEmpty α
⊢ (comap Prod.snd f).NeBot ↔ Nonempty α ∧ f.NeBot

case inr
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
hα : Nonempty α
⊢ (comap Prod.snd f).NeBot ↔ Nonempty α ∧ f.NeBot

tactic: rw [filter_eq_bot_of_isEmpty (f.comap _), ← not_iff_not]
state_before: case inl
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
hα : IsEmpty α
⊢ (comap Prod.snd f).NeBot ↔ Nonempty α ∧ f.NeBot
state_after: case inl
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
hα : IsEmpty α
⊢ ¬⊥.NeBot ↔ ¬(Nonempty α ∧ f.NeBot)

tactic: simp
state_before: case inl
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
hα : IsEmpty α
⊢ ¬⊥.NeBot ↔ ¬(Nonempty α ∧ f.NeBot)
state_after: no goals

tactic: simp [comap_neBot_iff_frequently, hα]
state_before: case inr
α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
hα : Nonempty α
⊢ (comap Prod.snd f).NeBot ↔ Nonempty α ∧ f.NeBot
state_after: no goals
Theorem: Affine.Triangle.affineSpan_orthocenter_point_le_altitude
File: Mathlib/Geometry/Euclidean/MongePoint.lean

tactic: refine spanPoints_subset_coe_of_subset_coe ?_
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i : Fin 3
⊢ affineSpan ℝ {t.orthocenter, t.points i} ≤ altitude t i
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i : Fin 3
⊢ {t.orthocenter, t.points i} ⊆ ↑(altitude t i)

tactic: rw [Set.insert_subset_iff, Set.singleton_subset_iff]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i : Fin 3
⊢ {t.orthocenter, t.points i} ⊆ ↑(altitude t i)
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i : Fin 3
⊢ t.orthocenter ∈ ↑(altitude t i) ∧ t.points i ∈ ↑(altitude t i)

tactic: exact ⟨t.orthocenter_mem_altitude, t.mem_altitude i⟩
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
t : Triangle ℝ P
i : Fin 3
⊢ t.orthocenter ∈ ↑(altitude t i) ∧ t.points i ∈ ↑(altitude t i)
state_after: no goals
Theorem: Real.sinh_pos_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean

tactic: simpa only [sinh_zero] using @sinh_lt_sinh 0 x
state_before: x y z : ℝ
⊢ 0 < sinh x ↔ 0 < x
state_after: no goals
Theorem: WeierstrassCurve.ofJ0_c₄
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

tactic: rw [ofJ0, c₄, b₂, b₄]
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
⊢ (ofJ0 R).c₄ = 0
state_after: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
⊢ ({ a₁ := 0, a₂ := 0, a₃ := 1, a₄ := 0, a₆ := 0 }.a₁ ^ 2 + 4 * { a₁ := 0, a₂ := 0, a₃ := 1, a₄ := 0, a₆ := 0 }.a₂) ^
        2 -
      24 *
        (2 * { a₁ := 0, a₂ := 0, a₃ := 1, a₄ := 0, a₆ := 0 }.a₄ +
          { a₁ := 0, a₂ := 0, a₃ := 1, a₄ := 0, a₆ := 0 }.a₁ * { a₁ := 0, a₂ := 0, a₃ := 1, a₄ := 0, a₆ := 0 }.a₃) =
    0

tactic: norm_num1
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
⊢ ({ a₁ := 0, a₂ := 0, a₃ := 1, a₄ := 0, a₆ := 0 }.a₁ ^ 2 + 4 * { a₁ := 0, a₂ := 0, a₃ := 1, a₄ := 0, a₆ := 0 }.a₂) ^
        2 -
      24 *
        (2 * { a₁ := 0, a₂ := 0, a₃ := 1, a₄ := 0, a₆ := 0 }.a₄ +
          { a₁ := 0, a₂ := 0, a₃ := 1, a₄ := 0, a₆ := 0 }.a₁ * { a₁ := 0, a₂ := 0, a₃ := 1, a₄ := 0, a₆ := 0 }.a₃) =
    0
state_after: no goals
Theorem: CategoryTheory.Limits.spanExt_hom_app_zero
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: dsimp [spanExt]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (spanExt iX iY iZ wf wg).hom.app WalkingSpan.zero = iX.hom
state_after: no goals
Theorem: tsub_tsub_tsub_le_tsub
File: Mathlib/Algebra/Order/Sub/Defs.lean

tactic: rw [tsub_le_iff_left, tsub_le_iff_left, add_left_comm]
state_before: α : Type u_1
β : Type u_2
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ c - a - (c - b) ≤ b - a
state_after: α : Type u_1
β : Type u_2
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ c ≤ c - b + (a + (b - a))

tactic: exact le_tsub_add.trans (add_le_add_left le_add_tsub _)
state_before: α : Type u_1
β : Type u_2
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ c ≤ c - b + (a + (b - a))
state_after: no goals
Theorem: Ordinal.bsup_eq_sup'
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simp (config := { unfoldPartialApp := true }) only [← sup_eq_bsup' r, enum_typein,
  familyOfBFamily', bfamilyOfFamily']
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
r : ι → ι → Prop
inst✝ : IsWellOrder ι r
f : ι → Ordinal.{max u v}
⊢ (type r).bsup (bfamilyOfFamily' r f) = sup f
state_after: no goals
Theorem: cfc_comp_const_mul
File: Mathlib/Topology/ContinuousFunction/FunctionalCalculus.lean

tactic: rw [cfc_comp' .., cfc_const_mul_id ..]
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹⁰ : CommSemiring R
inst✝⁹ : StarRing R
inst✝⁸ : MetricSpace R
inst✝⁷ : TopologicalSemiring R
inst✝⁶ : ContinuousStar R
inst✝⁵ : TopologicalSpace A
inst✝⁴ : Ring A
inst✝³ : StarRing A
inst✝² : Algebra R A
inst✝¹ : ContinuousFunctionalCalculus R p
f✝ g : R → R
a✝ : A
ha✝ : autoParam (p a✝) _auto✝
hf✝ : autoParam (ContinuousOn f✝ (spectrum R a✝)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a✝)) _auto✝
inst✝ : UniqueContinuousFunctionalCalculus R A
r : R
f : R → R
a : A
hf : autoParam (ContinuousOn f ((fun x => r * x) '' spectrum R a)) _auto✝
ha : autoParam (p a) _auto✝
⊢ cfc (fun x => f (r * x)) a = cfc f (r • a)
state_after: no goals
Theorem: MeasureTheory.ProbabilityMeasure.limsup_measure_closed_le_of_tendsto
File: Mathlib/MeasureTheory/Measure/Portmanteau.lean

tactic: apply FiniteMeasure.limsup_measure_closed_le_of_tendsto
  ((ProbabilityMeasure.tendsto_nhds_iff_toFiniteMeasure_tendsto_nhds L).mp μs_lim) F_closed
state_before: Ω : Type u_1
ι : Type u_2
L : Filter ι
inst✝³ : MeasurableSpace Ω
inst✝² : TopologicalSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
inst✝ : HasOuterApproxClosed Ω
μ : ProbabilityMeasure Ω
μs : ι → ProbabilityMeasure Ω
μs_lim : Tendsto μs L (𝓝 μ)
F : Set Ω
F_closed : IsClosed F
⊢ limsup (fun i => ↑(μs i) F) L ≤ ↑μ F
state_after: no goals
Theorem: Affine.Simplex.direction_mongePlane
File: Mathlib/Geometry/Euclidean/MongePoint.lean

tactic: rw [mongePlane_def, direction_inf_of_mem_inf s.mongePoint_mem_mongePlane, direction_mk',
  direction_affineSpan]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P (n + 2)
i₁ i₂ : Fin (n + 3)
⊢ (s.mongePlane i₁ i₂).direction = (Submodule.span ℝ {s.points i₁ -ᵥ s.points i₂})ᗮ ⊓ vectorSpan ℝ (Set.range s.points)
state_after: no goals