tasksource/leandojo huggingface dataset:
Theorem: OreLocalization.nontrivial_of_nonZeroDivisors
File: Mathlib/RingTheory/OreLocalization/Basic.lean

tactic: rw [OreLocalization.one_def, OreLocalization.zero_def] at h
state_before: R : Type u_1
inst✝² : Ring R
S : Submonoid R
inst✝¹ : OreSet S
inst✝ : Nontrivial R
hS : S ≤ R⁰
h : 0 = 1
⊢ False

tactic: apply nonZeroDivisors.coe_ne_zero 1 (numeratorHom_inj hS h).symm
state_before: R : Type u_1
inst✝² : Ring R
S : Submonoid R
inst✝¹ : OreSet S
inst✝ : Nontrivial R
hS : S ≤ R⁰
h : 0 /ₒ 1 = 1 /ₒ 1
⊢ False
Theorem: UniqueFactorizationMonoid.associated_iff_normalizedFactors_eq_normalizedFactors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: refine'
  ⟨fun h => _, fun h =>
    (normalizedFactors_prod hx).symm.trans (_root_.trans (by rw [h]) (normalizedFactors_prod hy))⟩
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x y : α
hx : x ≠ 0
hy : y ≠ 0
⊢ x ~ᵤ y ↔ normalizedFactors x = normalizedFactors y

tactic: apply le_antisymm <;> rw [← dvd_iff_normalizedFactors_le_normalizedFactors]
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x y : α
hx : x ≠ 0
hy : y ≠ 0
h : x ~ᵤ y
⊢ normalizedFactors x = normalizedFactors y

tactic: all_goals simp [*, h.dvd, h.symm.dvd]
state_before: case a
α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x y : α
hx : x ≠ 0
hy : y ≠ 0
h : x ~ᵤ y
⊢ x ∣ y

case a.hx
α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x y : α
hx : x ≠ 0
hy : y ≠ 0
h : x ~ᵤ y
⊢ x ≠ 0

case a.hy
α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x y : α
hx : x ≠ 0
hy : y ≠ 0
h : x ~ᵤ y
⊢ y ≠ 0

case a
α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x y : α
hx : x ≠ 0
hy : y ≠ 0
h : x ~ᵤ y
⊢ y ∣ x

case a.hx
α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x y : α
hx : x ≠ 0
hy : y ≠ 0
h : x ~ᵤ y
⊢ y ≠ 0

case a.hy
α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x y : α
hx : x ≠ 0
hy : y ≠ 0
h : x ~ᵤ y
⊢ x ≠ 0

tactic: rw [h]
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x y : α
hx : x ≠ 0
hy : y ≠ 0
h : normalizedFactors x = normalizedFactors y
⊢ Multiset.prod (normalizedFactors x) ~ᵤ Multiset.prod (normalizedFactors y)

tactic: simp [*, h.dvd, h.symm.dvd]
state_before: case a.hy
α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
x y : α
hx : x ≠ 0
hy : y ≠ 0
h : x ~ᵤ y
⊢ x ≠ 0
Theorem: isEmpty_ulift
File: Mathlib/Logic/IsEmpty.lean

tactic: simp only [← not_nonempty_iff, nonempty_ulift]
state_before: α✝ : Sort ?u.3602
β : Sort ?u.3605
γ : Sort ?u.3608
α : Type u_1
⊢ IsEmpty (ULift α) ↔ IsEmpty α
Theorem: HomologicalComplex.d_comp_d
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: by_cases hij : c.Rel i j
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
i j k : ι
⊢ d C i j ≫ d C j k = 0

tactic: by_cases hjk : c.Rel j k
state_before: case pos
ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
i j k : ι
hij : ComplexShape.Rel c i j
⊢ d C i j ≫ d C j k = 0

tactic: . rw [C.shape j k hjk, comp_zero]
state_before: case neg
ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
i j k : ι
hij : ComplexShape.Rel c i j
hjk : ¬ComplexShape.Rel c j k
⊢ d C i j ≫ d C j k = 0

tactic: exact C.d_comp_d' i j k hij hjk
state_before: case pos
ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
i j k : ι
hij : ComplexShape.Rel c i j
hjk : ComplexShape.Rel c j k
⊢ d C i j ≫ d C j k = 0

tactic: rw [C.shape j k hjk, comp_zero]
state_before: case neg
ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
i j k : ι
hij : ComplexShape.Rel c i j
hjk : ¬ComplexShape.Rel c j k
⊢ d C i j ≫ d C j k = 0

tactic: rw [C.shape i j hij, zero_comp]
state_before: case neg
ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
i j k : ι
hij : ¬ComplexShape.Rel c i j
⊢ d C i j ≫ d C j k = 0
Theorem: CategoryTheory.GrothendieckTopology.isoSheafify_inv
File: Mathlib/CategoryTheory/Sites/Sheafification.lean

tactic: apply J.sheafifyLift_unique
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
⊢ (isoSheafify J hP).inv = sheafifyLift J (𝟙 P) hP

tactic: simp [Iso.comp_inv_eq]
state_before: case a
C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P : Cᵒᵖ ⥤ D
hP : Presheaf.IsSheaf J P
⊢ toSheafify J P ≫ (isoSheafify J hP).inv = 𝟙 P
Theorem: Nat.map_ceil
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← map_natCast f, hf.le_iff_le]
state_before: F : Type u_3
α : Type u_1
β : Type u_2
inst✝⁴ : LinearOrderedSemiring α
inst✝³ : LinearOrderedSemiring β
inst✝² : FloorSemiring α
inst✝¹ : FloorSemiring β
inst✝ : RingHomClass F α β
a✝ : α
b : β
f : F
hf : StrictMono ↑f
a : α
n : ℕ
⊢ ↑f a ≤ ↑n ↔ a ≤ ↑n
Theorem: EuclideanGeometry.angle_add_angle_eq_pi_of_angle_eq_pi
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean

tactic: unfold angle at h
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 p4 : P
h : ∠ p2 p3 p4 = π
⊢ ∠ p1 p3 p2 + ∠ p1 p3 p4 = π

tactic: rw [angle_comm p1 p3 p2, angle_comm p1 p3 p4]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 p4 : P
h : InnerProductGeometry.angle (p2 -ᵥ p3) (p4 -ᵥ p3) = π
⊢ ∠ p1 p3 p2 + ∠ p1 p3 p4 = π

tactic: unfold angle
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 p4 : P
h : InnerProductGeometry.angle (p2 -ᵥ p3) (p4 -ᵥ p3) = π
⊢ ∠ p2 p3 p1 + ∠ p4 p3 p1 = π

tactic: exact angle_add_angle_eq_pi_of_angle_eq_pi _ h
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 p4 : P
h : InnerProductGeometry.angle (p2 -ᵥ p3) (p4 -ᵥ p3) = π
⊢ InnerProductGeometry.angle (p2 -ᵥ p3) (p1 -ᵥ p3) + InnerProductGeometry.angle (p4 -ᵥ p3) (p1 -ᵥ p3) = π
Theorem: Ordinal.one_le_iff_ne_zero
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: rw [one_le_iff_pos, Ordinal.pos_iff_ne_zero]
state_before: α : Type ?u.180072
β : Type ?u.180075
γ : Type ?u.180078
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
⊢ 1 ≤ o ↔ o ≠ 0
Theorem: Pi.card_Iio
File: Mathlib/Data/Pi/Interval.lean

tactic: rw [card_Iio_eq_card_Iic_sub_one, card_Iic]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝⁴ : DecidableEq ι
inst✝³ : Fintype ι
inst✝² : (i : ι) → DecidableEq (α i)
inst✝¹ : (i : ι) → PartialOrder (α i)
inst✝ : (i : ι) → LocallyFiniteOrderBot (α i)
b : (i : ι) → α i
⊢ Finset.card (Iio b) = ∏ i : ι, Finset.card (Iic (b i)) - 1
Theorem: Cardinal.mk_preimage_of_subset_range
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← lift_id (#↑(f ⁻¹' s)), ← lift_id (#↑(s))]
state_before: α β : Type u
f : α → β
s : Set β
h : s ⊆ range f
⊢ (#↑s) ≤ (#↑(f ⁻¹' s))

tactic: exact mk_preimage_of_subset_range_lift f s h
state_before: α β : Type u
f : α → β
s : Set β
h : s ⊆ range f
⊢ lift (#↑s) ≤ lift (#↑(f ⁻¹' s))
Theorem: affineSpan_eq_affineSpan_lineMap_units
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: have : s = Set.range ((↑) : s → P) := by simp
state_before: k : Type u_1
V : Type u_3
P : Type u_2
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Nontrivial k
s : Set P
p : P
hp : p ∈ s
w : ↑s → kˣ
⊢ affineSpan k (Set.range fun q => ↑(AffineMap.lineMap p ↑q) ↑(w q)) = affineSpan k s

tactic: conv_rhs =>
  rw [this]
state_before: k : Type u_1
V : Type u_3
P : Type u_2
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Nontrivial k
s : Set P
p : P
hp : p ∈ s
w : ↑s → kˣ
this : s = Set.range Subtype.val
⊢ affineSpan k (Set.range fun q => ↑(AffineMap.lineMap p ↑q) ↑(w q)) = affineSpan k s

tactic: apply le_antisymm
  <;> intro q hq
  <;> erw [mem_affineSpan_iff_eq_weightedVSubOfPoint_vadd k V _ (⟨p, hp⟩ : s) q] at hq ⊢
  <;> obtain ⟨t, μ, rfl⟩ := hq
  <;> use t
  <;> [use fun x => μ x * ↑(w x); use fun x => μ x * ↑(w x)⁻¹]
  <;> simp [smul_smul]
state_before: k : Type u_1
V : Type u_3
P : Type u_2
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Nontrivial k
s : Set P
p : P
hp : p ∈ s
w : ↑s → kˣ
this : s = Set.range Subtype.val
⊢ affineSpan k (Set.range fun q => ↑(AffineMap.lineMap p ↑q) ↑(w q)) = affineSpan k (Set.range Subtype.val)

tactic: simp
state_before: k : Type u_1
V : Type u_3
P : Type u_2
inst✝⁴ : Ring k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Nontrivial k
s : Set P
p : P
hp : p ∈ s
w : ↑s → kˣ
⊢ s = Set.range Subtype.val
Theorem: Ideal.mem_span_singleton
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: rw [eq_comm, mul_comm]
state_before: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
I : Ideal α
x y x✝ : α
⊢ x✝ * y = x ↔ x = y * x✝
Theorem: Set.diff_union_inter
File: Mathlib/Data/Set/Basic.lean

tactic: rw [union_comm]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u s t : Set α
⊢ s \ t ∪ s ∩ t = s

tactic: exact sup_inf_sdiff _ _
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u s t : Set α
⊢ s ∩ t ∪ s \ t = s
Theorem: Finsupp.comapDomain_add
File: Mathlib/Data/Finsupp/Basic.lean

tactic: ext
state_before: α : Type u_3
β : Type u_1
γ : Type ?u.306308
ι : Type ?u.306311
M : Type u_2
M' : Type ?u.306317
N : Type ?u.306320
P : Type ?u.306323
G : Type ?u.306326
H : Type ?u.306329
R : Type ?u.306332
S : Type ?u.306335
inst✝ : AddZeroClass M
f : α → β
v₁ v₂ : β →₀ M
hv₁ : Set.InjOn f (f ⁻¹' ↑v₁.support)
hv₂ : Set.InjOn f (f ⁻¹' ↑v₂.support)
hv₁₂ : Set.InjOn f (f ⁻¹' ↑(v₁ + v₂).support)
⊢ comapDomain f (v₁ + v₂) hv₁₂ = comapDomain f v₁ hv₁ + comapDomain f v₂ hv₂

tactic: simp only [comapDomain_apply, coe_add, Pi.add_apply]
state_before: case h
α : Type u_3
β : Type u_1
γ : Type ?u.306308
ι : Type ?u.306311
M : Type u_2
M' : Type ?u.306317
N : Type ?u.306320
P : Type ?u.306323
G : Type ?u.306326
H : Type ?u.306329
R : Type ?u.306332
S : Type ?u.306335
inst✝ : AddZeroClass M
f : α → β
v₁ v₂ : β →₀ M
hv₁ : Set.InjOn f (f ⁻¹' ↑v₁.support)
hv₂ : Set.InjOn f (f ⁻¹' ↑v₂.support)
hv₁₂ : Set.InjOn f (f ⁻¹' ↑(v₁ + v₂).support)
a✝ : α
⊢ ↑(comapDomain f (v₁ + v₂) hv₁₂) a✝ = ↑(comapDomain f v₁ hv₁ + comapDomain f v₂ hv₂) a✝
Theorem: tendsto_comp_coe_Ioi_atBot
File: Mathlib/Topology/Order/Basic.lean

tactic: rw [← map_coe_Ioi_atBot, tendsto_map'_iff]
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f : α → β
⊢ Tendsto (fun x => f ↑x) atBot l ↔ Tendsto f (𝓝[Ioi a] a) l

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f : α → β
⊢ Tendsto (fun x => f ↑x) atBot l ↔ Tendsto (f ∘ Subtype.val) atBot l
Theorem: Set.piecewise_le_piecewise
File: Mathlib/Data/Set/Function.lean

tactic: apply piecewise_le <;> intros <;> simp [*]
state_before: α : Type u_2
β : Type ?u.81703
γ : Type ?u.81706
ι : Sort ?u.81709
π : α → Type ?u.81714
δ✝ : α → Sort ?u.81719
s✝ : Set α
f g : (i : α) → δ✝ i
inst✝² : (j : α) → Decidable (j ∈ s✝)
δ : α → Type u_1
inst✝¹ : (i : α) → Preorder (δ i)
s : Set α
inst✝ : (j : α) → Decidable (j ∈ s)
f₁ f₂ g₁ g₂ : (i : α) → δ i
h₁ : ∀ (i : α), i ∈ s → f₁ i ≤ g₁ i
h₂ : ∀ (i : α), ¬i ∈ s → f₂ i ≤ g₂ i
⊢ piecewise s f₁ f₂ ≤ piecewise s g₁ g₂
Theorem: MeasureTheory.Measure.restrict_union_add_inter₀
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [← restrict_inter_add_diff₀ (s ∪ t) ht, union_inter_cancel_right, union_diff_right, ←
  restrict_inter_add_diff₀ s ht, add_comm, ← add_assoc, add_right_comm]
state_before: α : Type u_1
β : Type ?u.294414
γ : Type ?u.294417
δ : Type ?u.294420
ι : Type ?u.294423
R : Type ?u.294426
R' : Type ?u.294429
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t s : Set α
ht : NullMeasurableSet t
⊢ restrict μ (s ∪ t) + restrict μ (s ∩ t) = restrict μ s + restrict μ t
Theorem: Real.logb_mul
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: simp_rw [logb, log_mul hx hy, add_div]
state_before: b x y : ℝ
hx : x ≠ 0
hy : y ≠ 0
⊢ logb b (x * y) = logb b x + logb b y
Theorem: Real.Angle.cos_antiperiodic
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: intro θ
state_before: ⊢ Function.Antiperiodic cos ↑π

tactic: induction θ using Real.Angle.induction_on
state_before: θ : Angle
⊢ cos (θ + ↑π) = -cos θ

tactic: exact Real.cos_antiperiodic _
state_before: case h
x✝ : ℝ
⊢ cos (↑x✝ + ↑π) = -cos ↑x✝
Theorem: Rat.zero_iff_num_zero
File: Mathlib/Data/Rat/Defs.lean

tactic: simp [*]
state_before: a b c q : ℚ
x✝ : q = 0
⊢ q.num = 0
Theorem: card_finset_fin_le
File: Mathlib/Data/Fintype/Card.lean

tactic: simpa only [Fintype.card_fin] using s.card_le_univ
state_before: α : Type ?u.11098
β : Type ?u.11101
γ : Type ?u.11104
n : ℕ
s : Finset (Fin n)
⊢ card s ≤ n
Theorem: Metric.diam_thickening_le
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: by_cases hs : Bounded s
state_before: ι : Sort ?u.126772
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ ε : ℝ
s✝ t : Set α✝
x : α✝
α : Type u_1
inst✝ : PseudoMetricSpace α
s : Set α
hε : 0 ≤ ε
⊢ diam (thickening ε s) ≤ diam s + 2 * ε

tactic: obtain rfl | hε := hε.eq_or_lt
state_before: case neg
ι : Sort ?u.126772
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ ε : ℝ
s✝ t : Set α✝
x : α✝
α : Type u_1
inst✝ : PseudoMetricSpace α
s : Set α
hε : 0 ≤ ε
hs : ¬Bounded s
⊢ diam (thickening ε s) ≤ diam s + 2 * ε

tactic: exact (diam_mono (thickening_subset_cthickening _ _) hs.cthickening).trans
  (diam_cthickening_le _ hε)
state_before: case pos
ι : Sort ?u.126772
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ ε : ℝ
s✝ t : Set α✝
x : α✝
α : Type u_1
inst✝ : PseudoMetricSpace α
s : Set α
hε : 0 ≤ ε
hs : Bounded s
⊢ diam (thickening ε s) ≤ diam s + 2 * ε

tactic: simp [thickening_of_nonpos, diam_nonneg]
state_before: case neg.inl
ι : Sort ?u.126772
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ : ℝ
s✝ t : Set α✝
x : α✝
α : Type u_1
inst✝ : PseudoMetricSpace α
s : Set α
hs : ¬Bounded s
hε : 0 ≤ 0
⊢ diam (thickening 0 s) ≤ diam s + 2 * 0

tactic: rw [diam_eq_zero_of_unbounded (mt (Bounded.mono <| self_subset_thickening hε _) hs)]
state_before: case neg.inr
ι : Sort ?u.126772
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ ε : ℝ
s✝ t : Set α✝
x : α✝
α : Type u_1
inst✝ : PseudoMetricSpace α
s : Set α
hε✝ : 0 ≤ ε
hs : ¬Bounded s
hε : 0 < ε
⊢ diam (thickening ε s) ≤ diam s + 2 * ε

tactic: positivity
state_before: case neg.inr
ι : Sort ?u.126772
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ ε : ℝ
s✝ t : Set α✝
x : α✝
α : Type u_1
inst✝ : PseudoMetricSpace α
s : Set α
hε✝ : 0 ≤ ε
hs : ¬Bounded s
hε : 0 < ε
⊢ 0 ≤ diam s + 2 * ε
Theorem: List.zip_map_left
File: Mathlib/Data/List/Zip.lean

tactic: rw [← zip_map, map_id]
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type ?u.23064
ε : Type ?u.23067
f : α → γ
l₁ : List α
l₂ : List β
⊢ zip (map f l₁) l₂ = map (Prod.map f id) (zip l₁ l₂)
Theorem: Array.toArrayLit_eq
File: src/lean/Init/Data/Array/Basic.lean

tactic: apply ext'
state_before: α : Type u_1
as : Array α
n : Nat
hsz : size as = n
⊢ as = toArrayLit as n hsz

tactic: simp [toArrayLit, data_toArray]
state_before: case h
α : Type u_1
as : Array α
n : Nat
hsz : size as = n
⊢ as.data = (toArrayLit as n hsz).data

tactic: have hle : n ≤ as.size := hsz ▸ Nat.le_refl _
state_before: case h
α : Type u_1
as : Array α
n : Nat
hsz : size as = n
⊢ as.data = toListLitAux as n hsz n (_ : n ≤ size as) List.nil

tactic: have hge : as.size ≤ n := hsz ▸ Nat.le_refl _
state_before: case h
α : Type u_1
as : Array α
n : Nat
hsz : size as = n
hle : n ≤ size as
⊢ as.data = toListLitAux as n hsz n (_ : n ≤ size as) List.nil

tactic: have := go n hle
state_before: case h
α : Type u_1
as : Array α
n : Nat
hsz : size as = n
hle : n ≤ size as
hge : size as ≤ n
⊢ as.data = toListLitAux as n hsz n (_ : n ≤ size as) List.nil

tactic: rw [List.drop_eq_nil_of_le hge] at this
state_before: case h
α : Type u_1
as : Array α
n : Nat
hsz : size as = n
hle : n ≤ size as
hge : size as ≤ n
this : toListLitAux as n hsz n hle (List.drop n as.data) = as.data
⊢ as.data = toListLitAux as n hsz n (_ : n ≤ size as) List.nil

tactic: rw [this]
state_before: case h
α : Type u_1
as : Array α
n : Nat
hsz : size as = n
hle : n ≤ size as
hge : size as ≤ n
this : toListLitAux as n hsz n hle List.nil = as.data
⊢ as.data = toListLitAux as n hsz n (_ : n ≤ size as) List.nil

tactic: cases i <;> simp [getLit_eq, List.get_drop_eq_drop, toListLitAux, List.drop, go]
state_before: α : Type u_1
as : Array α
n : Nat
hsz : size as = n
i : Nat
hi : i ≤ size as
⊢ toListLitAux as n hsz i hi (List.drop i as.data) = as.data
Theorem: Set.exists_isOpen_le_add
File: Mathlib/MeasureTheory/Measure/Regular.lean

tactic: rcases eq_or_ne (μ A) ∞ with (H | H)
state_before: α : Type u_1
β : Type ?u.11634
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ : Measure α
A : Set α
μ : Measure α
inst✝ : OuterRegular μ
ε : ℝ≥0∞
hε : ε ≠ 0
⊢ ∃ U, U ⊇ A ∧ IsOpen U ∧ ↑↑μ U ≤ ↑↑μ A + ε

tactic: exact ⟨univ, subset_univ _, isOpen_univ, by simp only [H, _root_.top_add, le_top]⟩
state_before: case inl
α : Type u_1
β : Type ?u.11634
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ : Measure α
A : Set α
μ : Measure α
inst✝ : OuterRegular μ
ε : ℝ≥0∞
hε : ε ≠ 0
H : ↑↑μ A = ⊤
⊢ ∃ U, U ⊇ A ∧ IsOpen U ∧ ↑↑μ U ≤ ↑↑μ A + ε

tactic: simp only [H, _root_.top_add, le_top]
state_before: α : Type u_1
β : Type ?u.11634
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ : Measure α
A : Set α
μ : Measure α
inst✝ : OuterRegular μ
ε : ℝ≥0∞
hε : ε ≠ 0
H : ↑↑μ A = ⊤
⊢ ↑↑μ univ ≤ ↑↑μ A + ε

tactic: rcases A.exists_isOpen_lt_add H hε with ⟨U, AU, U_open, hU⟩
state_before: case inr
α : Type u_1
β : Type ?u.11634
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ : Measure α
A : Set α
μ : Measure α
inst✝ : OuterRegular μ
ε : ℝ≥0∞
hε : ε ≠ 0
H : ↑↑μ A ≠ ⊤
⊢ ∃ U, U ⊇ A ∧ IsOpen U ∧ ↑↑μ U ≤ ↑↑μ A + ε

tactic: exact ⟨U, AU, U_open, hU.le⟩
state_before: case inr.intro.intro.intro
α : Type u_1
β : Type ?u.11634
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ : Measure α
A : Set α
μ : Measure α
inst✝ : OuterRegular μ
ε : ℝ≥0∞
hε : ε ≠ 0
H : ↑↑μ A ≠ ⊤
U : Set α
AU : U ⊇ A
U_open : IsOpen U
hU : ↑↑μ U < ↑↑μ A + ε
⊢ ∃ U, U ⊇ A ∧ IsOpen U ∧ ↑↑μ U ≤ ↑↑μ A + ε
Theorem: Filter.map₂_right_comm
File: Mathlib/Order/Filter/NAry.lean

tactic: rw [map₂_swap n, map₂_swap n']
state_before: α : Type u_4
α' : Type ?u.39127
β : Type u_5
β' : Type ?u.39133
γ : Type u_3
γ' : Type ?u.39139
δ : Type u_2
δ' : Type u_6
ε : Type u_1
ε' : Type ?u.39151
m✝ : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
m : δ → γ → ε
n : α → β → δ
m' : α → γ → δ'
n' : δ' → β → ε
h_right_comm : ∀ (a : α) (b : β) (c : γ), m (n a b) c = n' (m' a c) b
⊢ map₂ m (map₂ n f g) h = map₂ n' (map₂ m' f h) g

tactic: exact map₂_assoc fun _ _ _ => h_right_comm _ _ _
state_before: α : Type u_4
α' : Type ?u.39127
β : Type u_5
β' : Type ?u.39133
γ : Type u_3
γ' : Type ?u.39139
δ : Type u_2
δ' : Type u_6
ε : Type u_1
ε' : Type ?u.39151
m✝ : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
m : δ → γ → ε
n : α → β → δ
m' : α → γ → δ'
n' : δ' → β → ε
h_right_comm : ∀ (a : α) (b : β) (c : γ), m (n a b) c = n' (m' a c) b
⊢ map₂ m (map₂ (fun a b => n b a) g f) h = map₂ (fun a b => n' b a) g (map₂ m' f h)
Theorem: segment_eq_image
File: Mathlib/Analysis/Convex/Segment.lean

tactic: simp only [add_sub_cancel]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.58852
G : Type ?u.58855
ι : Type ?u.58858
π : ι → Type ?u.58863
inst✝⁵ : OrderedRing 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : AddCommGroup F
inst✝² : AddCommGroup G
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z : E
x✝ : z ∈ [x-[𝕜]y]
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
hz : a • x + b • y = z
⊢ (fun θ => (a + b - θ) • x + θ • y) b = a • x + b • y
Theorem: CategoryTheory.Functor.essImage.unit_isIso
File: Mathlib/CategoryTheory/Adjunction/Reflective.lean

tactic: suffices (ofRightAdjoint i).unit.app A = h.getIso.inv ≫
    (ofRightAdjoint i).unit.app (i.obj (Functor.essImage.witness h)) ≫
    (leftAdjoint i ⋙ i).map h.getIso.hom by
  rw [this]
  infer_instance
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category C
inst✝² : Category D
inst✝¹ : Category E
i : D ⥤ C
inst✝ : Reflective i
A : C
h : A ∈ essImage i
⊢ IsIso ((ofRightAdjoint i).unit.app A)

tactic: rw [← NatTrans.naturality]
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category C
inst✝² : Category D
inst✝¹ : Category E
i : D ⥤ C
inst✝ : Reflective i
A : C
h : A ∈ essImage i
⊢ (ofRightAdjoint i).unit.app A =
    (getIso h).inv ≫ (ofRightAdjoint i).unit.app (i.obj (witness h)) ≫ (leftAdjoint i ⋙ i).map (getIso h).hom

tactic: simp
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category C
inst✝² : Category D
inst✝¹ : Category E
i : D ⥤ C
inst✝ : Reflective i
A : C
h : A ∈ essImage i
⊢ (ofRightAdjoint i).unit.app A = (getIso h).inv ≫ (𝟭 C).map (getIso h).hom ≫ (ofRightAdjoint i).unit.app A

tactic: rw [this]
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category C
inst✝² : Category D
inst✝¹ : Category E
i : D ⥤ C
inst✝ : Reflective i
A : C
h : A ∈ essImage i
this :
  (ofRightAdjoint i).unit.app A =
    (getIso h).inv ≫ (ofRightAdjoint i).unit.app (i.obj (witness h)) ≫ (leftAdjoint i ⋙ i).map (getIso h).hom
⊢ IsIso ((ofRightAdjoint i).unit.app A)

tactic: infer_instance
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category C
inst✝² : Category D
inst✝¹ : Category E
i : D ⥤ C
inst✝ : Reflective i
A : C
h : A ∈ essImage i
this :
  (ofRightAdjoint i).unit.app A =
    (getIso h).inv ≫ (ofRightAdjoint i).unit.app (i.obj (witness h)) ≫ (leftAdjoint i ⋙ i).map (getIso h).hom
⊢ IsIso ((getIso h).inv ≫ (ofRightAdjoint i).unit.app (i.obj (witness h)) ≫ (leftAdjoint i ⋙ i).map (getIso h).hom)
Theorem: Filter.sup_neBot
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [neBot_iff, not_and_or, Ne.def, sup_eq_bot_iff]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.62053
ι : Sort x
f✝ g✝ : Filter α
s t : Set α
f g : Filter α
⊢ NeBot (f ⊔ g) ↔ NeBot f ∨ NeBot g