tasksource/leandojo huggingface dataset:
Theorem: div_lt_div''
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [div_eq_mul_inv, div_eq_mul_inv, mul_comm b, mul_inv_lt_inv_mul_iff, mul_comm]
state_before: α : Type u
inst✝² : CommGroup α
inst✝¹ : Preorder α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c d : α
hab : a < b
hcd : c < d
⊢ a / d < b / c

tactic: exact mul_lt_mul_of_lt_of_lt hab hcd
state_before: α : Type u
inst✝² : CommGroup α
inst✝¹ : Preorder α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c d : α
hab : a < b
hcd : c < d
⊢ a * c < b * d
Theorem: MeasureTheory.restrict_dirac'
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: ext1 t ht
state_before: α : Type u_1
mα : MeasurableSpace α
a : α
s : Set α
hs : MeasurableSet s
inst✝ : Decidable (a ∈ s)
⊢ Measure.restrict (Measure.dirac a) s = if a ∈ s then Measure.dirac a else 0

tactic: simp only [Measure.restrict_apply ht, Measure.dirac_apply' _ (ht.inter hs), Set.indicator_apply,
  Set.mem_inter_iff, Pi.one_apply]
state_before: case h
α : Type u_1
mα : MeasurableSpace α
a : α
s : Set α
hs : MeasurableSet s
inst✝ : Decidable (a ∈ s)
t : Set α
ht : MeasurableSet t
⊢ ↑↑(Measure.restrict (Measure.dirac a) s) t = ↑↑(if a ∈ s then Measure.dirac a else 0) t

tactic: by_cases has : a ∈ s
state_before: case h
α : Type u_1
mα : MeasurableSpace α
a : α
s : Set α
hs : MeasurableSet s
inst✝ : Decidable (a ∈ s)
t : Set α
ht : MeasurableSet t
⊢ (if a ∈ t ∧ a ∈ s then 1 else 0) = ↑↑(if a ∈ s then Measure.dirac a else 0) t

tactic: simp only [has, and_true_iff, if_true]
state_before: case pos
α : Type u_1
mα : MeasurableSpace α
a : α
s : Set α
hs : MeasurableSet s
inst✝ : Decidable (a ∈ s)
t : Set α
ht : MeasurableSet t
has : a ∈ s
⊢ (if a ∈ t ∧ a ∈ s then 1 else 0) = ↑↑(if a ∈ s then Measure.dirac a else 0) t

tactic: split_ifs with hat
state_before: case pos
α : Type u_1
mα : MeasurableSpace α
a : α
s : Set α
hs : MeasurableSet s
inst✝ : Decidable (a ∈ s)
t : Set α
ht : MeasurableSet t
has : a ∈ s
⊢ (if a ∈ t then 1 else 0) = ↑↑(Measure.dirac a) t

tactic: rw [Measure.dirac_apply_of_mem hat]
state_before: case pos.inl
α : Type u_1
mα : MeasurableSpace α
a : α
s : Set α
hs : MeasurableSet s
inst✝ : Decidable (a ∈ s)
t : Set α
ht : MeasurableSet t
has : a ∈ s
hat : a ∈ t
⊢ 1 = ↑↑(Measure.dirac a) t

tactic: simp only [Measure.dirac_apply' _ ht, Set.indicator_apply, hat, if_false]
state_before: case pos.inr
α : Type u_1
mα : MeasurableSpace α
a : α
s : Set α
hs : MeasurableSet s
inst✝ : Decidable (a ∈ s)
t : Set α
ht : MeasurableSet t
has : a ∈ s
hat : ¬a ∈ t
⊢ 0 = ↑↑(Measure.dirac a) t

tactic: simp only [has, and_false_iff, if_false, Measure.coe_zero, Pi.zero_apply]
state_before: case neg
α : Type u_1
mα : MeasurableSpace α
a : α
s : Set α
hs : MeasurableSet s
inst✝ : Decidable (a ∈ s)
t : Set α
ht : MeasurableSet t
has : ¬a ∈ s
⊢ (if a ∈ t ∧ a ∈ s then 1 else 0) = ↑↑(if a ∈ s then Measure.dirac a else 0) t
Theorem: Num.mod_to_nat
File: Mathlib/Data/Num/Lemmas.lean

tactic: simp
state_before: ⊢ ↑(0 % 0) = ↑0 % ↑0
Theorem: isClosed_nonneg
File: Mathlib/Analysis/Normed/Order/Lattice.lean

tactic: suffices { x : E | 0 ≤ x } = NegPart.neg ⁻¹' {(0 : E)} by
  rw [this]
  exact IsClosed.preimage continuous_neg' isClosed_singleton
state_before: α : Type ?u.119963
inst✝¹ : NormedLatticeAddCommGroup α
E : Type u_1
inst✝ : NormedLatticeAddCommGroup E
⊢ IsClosed {x | 0 ≤ x}

tactic: ext1 x
state_before: α : Type ?u.119963
inst✝¹ : NormedLatticeAddCommGroup α
E : Type u_1
inst✝ : NormedLatticeAddCommGroup E
⊢ {x | 0 ≤ x} = NegPart.neg ⁻¹' {0}

tactic: simp only [Set.mem_preimage, Set.mem_singleton_iff, Set.mem_setOf_eq,
  @neg_eq_zero_iff E _ _ (OrderedAddCommGroup.to_covariantClass_left_le E)  ]
state_before: case h
α : Type ?u.119963
inst✝¹ : NormedLatticeAddCommGroup α
E : Type u_1
inst✝ : NormedLatticeAddCommGroup E
x : E
⊢ x ∈ {x | 0 ≤ x} ↔ x ∈ NegPart.neg ⁻¹' {0}

tactic: rw [this]
state_before: α : Type ?u.119963
inst✝¹ : NormedLatticeAddCommGroup α
E : Type u_1
inst✝ : NormedLatticeAddCommGroup E
this : {x | 0 ≤ x} = NegPart.neg ⁻¹' {0}
⊢ IsClosed {x | 0 ≤ x}

tactic: exact IsClosed.preimage continuous_neg' isClosed_singleton
state_before: α : Type ?u.119963
inst✝¹ : NormedLatticeAddCommGroup α
E : Type u_1
inst✝ : NormedLatticeAddCommGroup E
this : {x | 0 ≤ x} = NegPart.neg ⁻¹' {0}
⊢ IsClosed (NegPart.neg ⁻¹' {0})
Theorem: Nat.multichoose_one
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: induction' k with k IH
state_before: k : ℕ
⊢ multichoose 1 k = 1

tactic: simp [multichoose_succ_succ 0 k, IH]
state_before: case succ
k : ℕ
IH : multichoose 1 k = 1
⊢ multichoose 1 (succ k) = 1

tactic: simp
state_before: case zero

⊢ multichoose 1 zero = 1
Theorem: ContinuousMultilinearMap.norm_mkPiAlgebraFin_le_of_pos
File: Mathlib/Analysis/NormedSpace/Multilinear.lean

tactic: obtain ⟨n, rfl⟩ := Nat.exists_eq_succ_of_ne_zero hn.ne'
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁶ : Fintype ι
inst✝¹⁵ : Fintype ι'
inst✝¹⁴ : NontriviallyNormedField 𝕜
inst✝¹³ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹² : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁹ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁸ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁷ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝⁶ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
inst✝³ : NormedAddCommGroup G'
inst✝² : NormedSpace 𝕜 G'
A : Type u_1
inst✝¹ : NormedRing A
inst✝ : NormedAlgebra 𝕜 A
hn : 0 < n
⊢ ‖ContinuousMultilinearMap.mkPiAlgebraFin 𝕜 n A‖ ≤ 1

tactic: exact norm_mkPiAlgebraFin_succ_le
state_before: case intro
𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹⁶ : Fintype ι
inst✝¹⁵ : Fintype ι'
inst✝¹⁴ : NontriviallyNormedField 𝕜
inst✝¹³ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹² : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁹ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁸ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
inst✝⁵ : NormedAddCommGroup G'
inst✝⁴ : NormedSpace 𝕜 G'
A : Type u_1
inst✝³ : NormedRing A
inst✝² : NormedAlgebra 𝕜 A
n : ℕ
Ei : Fin (Nat.succ (Nat.succ n)) → Type wEi
inst✝¹ : (i : Fin (Nat.succ (Nat.succ n))) → NormedAddCommGroup (Ei i)
inst✝ : (i : Fin (Nat.succ (Nat.succ n))) → NormedSpace 𝕜 (Ei i)
hn : 0 < Nat.succ n
⊢ ‖ContinuousMultilinearMap.mkPiAlgebraFin 𝕜 (Nat.succ n) A‖ ≤ 1
Theorem: Real.sin_pi_div_eight
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: trans sin (π / 2 ^ 3)
state_before: x : ℝ
⊢ sin (π / 8) = sqrt (2 - sqrt 2) / 2

tactic: congr
state_before: x : ℝ
⊢ sin (π / 8) = sin (π / 2 ^ 3)

x : ℝ
⊢ sin (π / 2 ^ 3) = sqrt (2 - sqrt 2) / 2

tactic: norm_num
state_before: case e_x.e_a
x : ℝ
⊢ 8 = 2 ^ 3

x : ℝ
⊢ sin (π / 2 ^ 3) = sqrt (2 - sqrt 2) / 2

tactic: simp
state_before: x : ℝ
⊢ sin (π / 2 ^ 3) = sqrt (2 - sqrt 2) / 2
Theorem: IsometryEquiv.preimage_ball
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: rw [← h.isometry.preimage_ball (h.symm x) r, h.apply_symm_apply]
state_before: ι : Type ?u.1037072
α : Type u
β : Type v
γ : Type w
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
h✝ h : α ≃ᵢ β
x : β
r : ℝ
⊢ ↑h ⁻¹' Metric.ball x r = Metric.ball (↑(IsometryEquiv.symm h) x) r
Theorem: Num.ofInt'_toZNum
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [Nat.cast_succ, Num.add_one, toZNum_succ, ofInt'_toZNum n, Nat.cast_succ, succ_ofInt',
  ZNum.add_one]
state_before: α : Type ?u.860270
n : ℕ
⊢ toZNum ↑(n + 1) = ZNum.ofInt' ↑(n + 1)
Theorem: Ordnode.Bounded.dual
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: cases o₁ <;> cases o₂ <;> trivial
state_before: α : Type u_1
inst✝ : Preorder α
o₁ : WithBot α
o₂ : WithTop α
h : Bounded nil o₁ o₂
⊢ Bounded (Ordnode.dual nil) o₂ o₁
Theorem: AlgebraicTopology.DoldKan.N₁Γ₀_inv_app_f_f
File: Mathlib/AlgebraicTopology/DoldKan/GammaCompN.lean

tactic: rw [N₁Γ₀_inv_app]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
K : ChainComplex C ℕ
n : ℕ
⊢ HomologicalComplex.Hom.f (N₁Γ₀.inv.app K).f n =
    HomologicalComplex.Hom.f (Splitting.toKaroubiNondegComplexIsoN₁ (Γ₀.splitting K)).hom.f n

tactic: apply id_comp
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
K : ChainComplex C ℕ
n : ℕ
⊢ HomologicalComplex.Hom.f
      ((toKaroubi (ChainComplex C ℕ)).map (Γ₀NondegComplexIso K).inv ≫
          (Splitting.toKaroubiNondegComplexIsoN₁ (Γ₀.splitting K)).hom).f
      n =
    HomologicalComplex.Hom.f (Splitting.toKaroubiNondegComplexIsoN₁ (Γ₀.splitting K)).hom.f n
Theorem: CategoryTheory.Arrow.AugmentedCechNerve.ExtraDegeneracy.s_comp_π_0
File: Mathlib/AlgebraicTopology/ExtraDegeneracy.lean

tactic: dsimp [ExtraDegeneracy.s]
state_before: C : Type u_2
inst✝¹ : Category C
f : Arrow C
inst✝ : ∀ (n : ℕ), HasWidePullback f.right (fun x => f.left) fun x => f.hom
S : SplitEpi f.hom
n : ℕ
⊢ s f S n ≫ WidePullback.π (fun x => f.hom) 0 = (WidePullback.base fun x => f.hom) ≫ S.section_

tactic: simp only [WidePullback.lift_π]
state_before: C : Type u_2
inst✝¹ : Category C
f : Arrow C
inst✝ : ∀ (n : ℕ), HasWidePullback f.right (fun x => f.left) fun x => f.hom
S : SplitEpi f.hom
n : ℕ
⊢ WidePullback.lift (WidePullback.base fun x => f.hom)
        (fun i =>
          if x : i = 0 then (WidePullback.base fun x => f.hom) ≫ S.section_
          else WidePullback.π (fun x => f.hom) (Fin.pred i x))
        (_ :
          ∀ (i : Fin (SimplexCategory.len [n + 1].op.unop + 1)),
            (fun i =>
                    if x : i = 0 then (WidePullback.base fun x => f.hom) ≫ S.section_
                    else WidePullback.π (fun x => f.hom) (Fin.pred i x))
                  i ≫
                f.hom =
              WidePullback.base fun x => f.hom) ≫
      WidePullback.π (fun x => f.hom) 0 =
    (WidePullback.base fun x => f.hom) ≫ S.section_

tactic: rfl
state_before: C : Type u_2
inst✝¹ : Category C
f : Arrow C
inst✝ : ∀ (n : ℕ), HasWidePullback f.right (fun x => f.left) fun x => f.hom
S : SplitEpi f.hom
n : ℕ
⊢ (if h : True then (WidePullback.base fun x => f.hom) ≫ S.section_
    else WidePullback.π (fun x => f.hom) (Fin.pred 0 (_ : ¬0 = 0))) =
    (WidePullback.base fun x => f.hom) ≫ S.section_
Theorem: AlgebraicGeometry.StructureSheaf.toBasicOpen_mk'
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

tactic: rw [toOpen_eq_const, toOpen_eq_const, const_mul_cancel']
state_before: R : Type u
inst✝ : CommRing R
s f : R
g : { x // x ∈ Submonoid.powers s }
⊢ ↑(toOpen R (PrimeSpectrum.basicOpen s)) f =
    ↑(toOpen R (PrimeSpectrum.basicOpen s)) ↑g *
      const R f (↑g) (PrimeSpectrum.basicOpen s)
        (_ : ∀ (x : ↑(PrimeSpectrum.Top R)), x ∈ PrimeSpectrum.basicOpen s → ↑g ∈ Ideal.primeCompl x.asIdeal)
Theorem: Finset.prod_Ico_eq_div
File: Mathlib/Algebra/BigOperators/Intervals.lean

tactic: simpa only [div_eq_mul_inv] using prod_Ico_eq_mul_inv f h
state_before: α : Type u
β : Type v
γ : Type w
s₂ s₁ s : Finset α
a : α
g f✝ : α → β
inst✝¹ : CommMonoid β
δ : Type u_1
inst✝ : CommGroup δ
f : ℕ → δ
m n : ℕ
h : m ≤ n
⊢ ∏ k in Ico m n, f k = (∏ k in range n, f k) / ∏ k in range m, f k
Theorem: Polynomial.reflect_C_mul
File: Mathlib/Data/Polynomial/Reverse.lean

tactic: ext
state_before: R : Type u_1
inst✝ : Semiring R
f✝ f : R[X]
r : R
N : ℕ
⊢ reflect N (↑C r * f) = ↑C r * reflect N f

tactic: simp only [coeff_reflect, coeff_C_mul]
state_before: case a
R : Type u_1
inst✝ : Semiring R
f✝ f : R[X]
r : R
N n✝ : ℕ
⊢ coeff (reflect N (↑C r * f)) n✝ = coeff (↑C r * reflect N f) n✝
Theorem: MvPolynomial.killCompl_comp_rename
File: Mathlib/Data/MvPolynomial/Rename.lean

tactic: dsimp
state_before: σ : Type u_1
τ : Type u_3
α : Type ?u.345007
R : Type u_2
S : Type ?u.345013
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
hf : Injective f
i : σ
⊢ ↑(AlgHom.comp (killCompl hf) (rename f)) (X i) = ↑(AlgHom.id R (MvPolynomial σ R)) (X i)

tactic: rw [rename, killCompl, aeval_X, comp_apply, aeval_X, dif_pos, Equiv.ofInjective_symm_apply]
state_before: σ : Type u_1
τ : Type u_3
α : Type ?u.345007
R : Type u_2
S : Type ?u.345013
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
hf : Injective f
i : σ
⊢ ↑(killCompl hf) (↑(rename f) (X i)) = X i
Theorem: NormedSpace.image_isVonNBounded_iff
File: Mathlib/Analysis/LocallyConvex/Bounded.lean

tactic: simp_rw [isVonNBounded_iff', Set.ball_image_iff]
state_before: 𝕜 : Type u_2
𝕜' : Type ?u.256544
E : Type u_3
E' : Type u_1
F : Type ?u.256553
ι : Type ?u.256556
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : E' → E
s : Set E'
⊢ Bornology.IsVonNBounded 𝕜 (f '' s) ↔ ∃ r, ∀ (x : E'), x ∈ s → ‖f x‖ ≤ r
Theorem: Finset.sum_smul_vsub_eq_affineCombination_vsub
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: simp_rw [affineCombination_apply, vadd_vsub_vadd_cancel_right]
state_before: k : Type u_3
V : Type u_1
P : Type u_4
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type ?u.340261
s₂ : Finset ι₂
w : ι → k
p₁ p₂ : ι → P
⊢ ∑ i in s, w i • (p₁ i -ᵥ p₂ i) = ↑(affineCombination k s p₁) w -ᵥ ↑(affineCombination k s p₂) w

tactic: exact s.sum_smul_vsub_eq_weightedVSubOfPoint_sub _ _ _ _
state_before: k : Type u_3
V : Type u_1
P : Type u_4
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type ?u.340261
s₂ : Finset ι₂
w : ι → k
p₁ p₂ : ι → P
⊢ ∑ i in s, w i • (p₁ i -ᵥ p₂ i) =
    ↑(weightedVSubOfPoint s p₁ (Classical.choice (_ : Nonempty P))) w -
      ↑(weightedVSubOfPoint s p₂ (Classical.choice (_ : Nonempty P))) w
Theorem: lt_of_mul_lt_mul_of_le₀
File: Mathlib/Algebra/Order/WithZero.lean

tactic: have ha : a ≠ 0 := ne_of_gt (lt_of_lt_of_le hc hh)
state_before: α : Type u_1
a b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
h : a * b < c * d
hc : 0 < c
hh : c ≤ a
⊢ b < d

tactic: simp_rw [← inv_le_inv₀ ha (ne_of_gt hc)] at hh
state_before: α : Type u_1
a b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
h : a * b < c * d
hc : 0 < c
hh : c ≤ a
ha : a ≠ 0
⊢ b < d

tactic: have := mul_lt_mul_of_lt_of_le₀ hh (inv_ne_zero (ne_of_gt hc)) h
state_before: α : Type u_1
a b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
h : a * b < c * d
hc : 0 < c
ha : a ≠ 0
hh : a⁻¹ ≤ c⁻¹
⊢ b < d

tactic: simpa [inv_mul_cancel_left₀ ha, inv_mul_cancel_left₀ (ne_of_gt hc)] using this
state_before: α : Type u_1
a b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
h : a * b < c * d
hc : 0 < c
ha : a ≠ 0
hh : a⁻¹ ≤ c⁻¹
this : a⁻¹ * (a * b) < c⁻¹ * (c * d)
⊢ b < d
Theorem: Int.even_mul_succ_self
File: Mathlib/Data/Int/Parity.lean

tactic: simpa [even_mul, parity_simps] using n.even_or_odd
state_before: m n✝ n : ℤ
⊢ Even (n * (n + 1))
Theorem: Mathlib.Tactic.Ring.neg_mul
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R✝ : Type ?u.204257
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝¹ : CommSemiring R✝
R : Type u_1
inst✝ : Ring R
a₁ : R
a₂ : ℕ
a₃ b : R
x✝ : -a₃ = b
⊢ -(a₁ ^ a₂ * a₃) = a₁ ^ a₂ * b

tactic: simp
state_before: u : Lean.Level
R✝ : Type ?u.204257
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝¹ : CommSemiring R✝
R : Type u_1
inst✝ : Ring R
a₁ : R
a₂ : ℕ
a₃ : R
⊢ -(a₁ ^ a₂ * a₃) = a₁ ^ a₂ * -a₃
Theorem: Units.mul_inv_of_eq
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [← h, u.mul_inv]
state_before: α : Type u
inst✝ : Monoid α
a✝ b c u : αˣ
a : α
h : ↑u = a
⊢ a * ↑u⁻¹ = 1
Theorem: singleton_div_closedBall
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: simp_rw [div_eq_mul_inv, inv_closedBall, singleton_mul_closedBall]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ {x} / closedBall y δ = closedBall (x / y) δ
Theorem: IsSelfAdjoint.zpow
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: simp only [isSelfAdjoint_iff, star_zpow₀, hx.star_eq]
state_before: R : Type u_1
A : Type ?u.46017
inst✝¹ : DivisionSemiring R
inst✝ : StarRing R
x : R
hx : IsSelfAdjoint x
n : ℤ
⊢ IsSelfAdjoint (x ^ n)
Theorem: SignType.neg_one_lt_iff
File: Mathlib/Data/Sign.lean

tactic: cases a <;> decide
state_before: a : SignType
⊢ -1 < a ↔ 0 ≤ a
Theorem: convexHull_ediam
File: Mathlib/Analysis/Convex/Normed.lean

tactic: refine' (EMetric.diam_le fun x hx y hy => _).antisymm (EMetric.diam_mono <| subset_convexHull ℝ s)
state_before: ι : Type ?u.38573
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s✝ t s : Set E
⊢ EMetric.diam (↑(convexHull ℝ).toOrderHom s) = EMetric.diam s

tactic: rcases convexHull_exists_dist_ge2 hx hy with ⟨x', hx', y', hy', H⟩
state_before: ι : Type ?u.38573
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s✝ t s : Set E
x : E
hx : x ∈ ↑(convexHull ℝ).toOrderHom s
y : E
hy : y ∈ ↑(convexHull ℝ).toOrderHom s
⊢ edist x y ≤ EMetric.diam s

tactic: rw [edist_dist]
state_before: case intro.intro.intro.intro
ι : Type ?u.38573
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s✝ t s : Set E
x : E
hx : x ∈ ↑(convexHull ℝ).toOrderHom s
y : E
hy : y ∈ ↑(convexHull ℝ).toOrderHom s
x' : E
hx' : x' ∈ s
y' : E
hy' : y' ∈ s
H : dist x y ≤ dist x' y'
⊢ edist x y ≤ EMetric.diam s

tactic: apply le_trans (ENNReal.ofReal_le_ofReal H)
state_before: case intro.intro.intro.intro
ι : Type ?u.38573
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s✝ t s : Set E
x : E
hx : x ∈ ↑(convexHull ℝ).toOrderHom s
y : E
hy : y ∈ ↑(convexHull ℝ).toOrderHom s
x' : E
hx' : x' ∈ s
y' : E
hy' : y' ∈ s
H : dist x y ≤ dist x' y'
⊢ ENNReal.ofReal (dist x y) ≤ EMetric.diam s

tactic: rw [← edist_dist]
state_before: case intro.intro.intro.intro
ι : Type ?u.38573
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s✝ t s : Set E
x : E
hx : x ∈ ↑(convexHull ℝ).toOrderHom s
y : E
hy : y ∈ ↑(convexHull ℝ).toOrderHom s
x' : E
hx' : x' ∈ s
y' : E
hy' : y' ∈ s
H : dist x y ≤ dist x' y'
⊢ ENNReal.ofReal (dist x' y') ≤ EMetric.diam s

tactic: exact EMetric.edist_le_diam_of_mem hx' hy'
state_before: case intro.intro.intro.intro
ι : Type ?u.38573
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s✝ t s : Set E
x : E
hx : x ∈ ↑(convexHull ℝ).toOrderHom s
y : E
hy : y ∈ ↑(convexHull ℝ).toOrderHom s
x' : E
hx' : x' ∈ s
y' : E
hy' : y' ∈ s
H : dist x y ≤ dist x' y'
⊢ edist x' y' ≤ EMetric.diam s
Theorem: Nat.cast_pred
File: Mathlib/Data/Int/Cast/Basic.lean

tactic: cases h
state_before: R : Type u
inst✝ : AddGroupWithOne R
h : 0 < 0
⊢ ↑(0 - 1) = ↑0 - 1

tactic: rw [cast_succ, add_sub_cancel]
state_before: R : Type u
inst✝ : AddGroupWithOne R
n : ℕ
x✝ : 0 < n + 1
⊢ ↑(n + 1 - 1) = ↑(n + 1) - 1

tactic: rfl
state_before: R : Type u
inst✝ : AddGroupWithOne R
n : ℕ
x✝ : 0 < n + 1
⊢ ↑(n + 1 - 1) = ↑n
Theorem: List.length_join
File: Mathlib/Data/List/Join.lean

tactic: induction L <;> [rfl; simp only [*, join, map, sum_cons, length_append]]
state_before: α : Type u_1
β : Type ?u.4048
L : List (List α)
⊢ length (join L) = sum (map length L)
Theorem: Nat.prod_prime_factors_dvd
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: by_cases hn : n = 0
state_before: n : ℕ
⊢ ∏ p in toFinset (factors n), p ∣ n

tactic: simpa [prod_factors hn] using Multiset.toFinset_prod_dvd_prod (n.factors : Multiset ℕ)
state_before: case neg
n : ℕ
hn : ¬n = 0
⊢ ∏ p in toFinset (factors n), p ∣ n

tactic: subst hn
state_before: case pos
n : ℕ
hn : n = 0
⊢ ∏ p in toFinset (factors n), p ∣ n

tactic: simp
state_before: case pos

⊢ ∏ p in toFinset (factors 0), p ∣ 0
Theorem: Set.insert_sigma
File: Mathlib/Data/Set/Sigma.lean

tactic: rw [insert_eq, union_sigma, singleton_sigma]
state_before: ι : Type u_1
ι' : Type ?u.9903
α : ι → Type u_2
β : ι → Type ?u.9913
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i j : ι
a : α i
⊢ Set.Sigma (insert i s) t = Sigma.mk i '' t i ∪ Set.Sigma s t

tactic: exact a
state_before: ι : Type u_1
ι' : Type ?u.9903
α : ι → Type u_2
β : ι → Type ?u.9913
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i j : ι
a : α i
⊢ α i
Theorem: affineIndependent_of_ne_of_not_mem_of_mem_of_mem
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

tactic: rw [← affineIndependent_equiv (Equiv.swap (0 : Fin 3) 2)]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.468482
s : AffineSubspace k P
p₁ p₂ p₃ : P
hp₂p₃ : p₂ ≠ p₃
hp₁ : ¬p₁ ∈ s
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
⊢ AffineIndependent k ![p₁, p₂, p₃]

tactic: convert affineIndependent_of_ne_of_mem_of_mem_of_not_mem hp₂p₃.symm hp₃ hp₂ hp₁ using 1
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.468482
s : AffineSubspace k P
p₁ p₂ p₃ : P
hp₂p₃ : p₂ ≠ p₃
hp₁ : ¬p₁ ∈ s
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
⊢ AffineIndependent k (![p₁, p₂, p₃] ∘ ↑(Equiv.swap 0 2))

tactic: ext x
state_before: case h.e'_9
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.468482
s : AffineSubspace k P
p₁ p₂ p₃ : P
hp₂p₃ : p₂ ≠ p₃
hp₁ : ¬p₁ ∈ s
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
⊢ ![p₁, p₂, p₃] ∘ ↑(Equiv.swap 0 2) = ![p₃, p₂, p₁]

tactic: fin_cases x <;> rfl
state_before: case h.e'_9.h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type ?u.468482
s : AffineSubspace k P
p₁ p₂ p₃ : P
hp₂p₃ : p₂ ≠ p₃
hp₁ : ¬p₁ ∈ s
hp₂ : p₂ ∈ s
hp₃ : p₃ ∈ s
x : Fin 3
⊢ (![p₁, p₂, p₃] ∘ ↑(Equiv.swap 0 2)) x = Matrix.vecCons p₃ ![p₂, p₁] x
Theorem: WithBot.unbot'_eq_self_iff
File: Mathlib/Order/WithBot.lean

tactic: simp [unbot'_eq_iff]
state_before: α : Type u_1
β : Type ?u.4491
γ : Type ?u.4494
δ : Type ?u.4497
a b d : α
x : WithBot α
⊢ unbot' d x = d ↔ x = ↑d ∨ x = ⊥
Theorem: QuotientGroup.mk_out'_eq_mul
File: Mathlib/GroupTheory/Coset.lean

tactic: rw [mul_inv_cancel_left]
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
g : α
⊢ Quotient.out' ↑g = g * ↑{ val := g⁻¹ * Quotient.out' ↑g, property := (_ : g⁻¹ * Quotient.out' ↑g ∈ s) }
Theorem: integrableOn_Ico_iff_integrableOn_Ioo
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: rw [measure_singleton]
state_before: α : Type u_1
β : Type ?u.4224895
E : Type u_2
F : Type ?u.4224901
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
inst✝² : PartialOrder α
inst✝¹ : MeasurableSingletonClass α
f : α → E
μ : MeasureTheory.Measure α
a b : α
inst✝ : NoAtoms μ
⊢ ↑↑μ {a} ≠ ⊤

tactic: exact ENNReal.zero_ne_top
state_before: α : Type u_1
β : Type ?u.4224895
E : Type u_2
F : Type ?u.4224901
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
inst✝² : PartialOrder α
inst✝¹ : MeasurableSingletonClass α
f : α → E
μ : MeasureTheory.Measure α
a b : α
inst✝ : NoAtoms μ
⊢ 0 ≠ ⊤
Theorem: Filter.limsup_compl
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp only [limsup_eq_iInf_iSup, compl_iInf, compl_iSup, liminf_eq_iSup_iInf, Function.comp_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.169453
ι : Type ?u.169456
inst✝ : CompleteBooleanAlgebra α
f : Filter β
u : β → α
⊢ limsup u fᶜ = liminf (compl ∘ u) f
Theorem: Pmf.toOuterMeasure_apply_inter_support
File: Mathlib/Probability/ProbabilityMassFunction/Basic.lean

tactic: simp only [toOuterMeasure_apply, Pmf.support, Set.indicator_inter_support]
state_before: α : Type u_1
β : Type ?u.28546
γ : Type ?u.28549
p : Pmf α
s t : Set α
⊢ ↑(toOuterMeasure p) (s ∩ support p) = ↑(toOuterMeasure p) s