tasksource/leandojo huggingface dataset:
Theorem: Besicovitch.card_le_multiplicity
File: Mathlib/MeasureTheory/Covering/BesicovitchVectorSpace.lean

tactic: apply le_csSup
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
s : Finset E
hs : ∀ (c : E), c ∈ s → ‖c‖ ≤ 2
h's : ∀ (c : E), c ∈ s → ∀ (d : E), d ∈ s → c ≠ d → 1 ≤ ‖c - d‖
⊢ Finset.card s ≤ multiplicity E

tactic: refine' ⟨5 ^ finrank ℝ E, _⟩
state_before: case h₁
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
s : Finset E
hs : ∀ (c : E), c ∈ s → ‖c‖ ≤ 2
h's : ∀ (c : E), c ∈ s → ∀ (d : E), d ∈ s → c ≠ d → 1 ≤ ‖c - d‖
⊢ BddAbove
    {N |
      ∃ s, Finset.card s = N ∧ (∀ (c : E), c ∈ s → ‖c‖ ≤ 2) ∧ ∀ (c : E), c ∈ s → ∀ (d : E), d ∈ s → c ≠ d → 1 ≤ ‖c - d‖}

tactic: rintro _ ⟨s, ⟨rfl, h⟩⟩
state_before: case h₁
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
s : Finset E
hs : ∀ (c : E), c ∈ s → ‖c‖ ≤ 2
h's : ∀ (c : E), c ∈ s → ∀ (d : E), d ∈ s → c ≠ d → 1 ≤ ‖c - d‖
⊢ 5 ^ finrank ℝ E ∈
    upperBounds
      {N |
        ∃ s,
          Finset.card s = N ∧ (∀ (c : E), c ∈ s → ‖c‖ ≤ 2) ∧ ∀ (c : E), c ∈ s → ∀ (d : E), d ∈ s → c ≠ d → 1 ≤ ‖c - d‖}

tactic: exact Besicovitch.card_le_of_separated s h.1 h.2
state_before: case h₁.intro.intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
s✝ : Finset E
hs : ∀ (c : E), c ∈ s✝ → ‖c‖ ≤ 2
h's : ∀ (c : E), c ∈ s✝ → ∀ (d : E), d ∈ s✝ → c ≠ d → 1 ≤ ‖c - d‖
s : Finset E
h : (∀ (c : E), c ∈ s → ‖c‖ ≤ 2) ∧ ∀ (c : E), c ∈ s → ∀ (d : E), d ∈ s → c ≠ d → 1 ≤ ‖c - d‖
⊢ Finset.card s ≤ 5 ^ finrank ℝ E

tactic: simp only [mem_setOf_eq, Ne.def]
state_before: case h₂
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
s : Finset E
hs : ∀ (c : E), c ∈ s → ‖c‖ ≤ 2
h's : ∀ (c : E), c ∈ s → ∀ (d : E), d ∈ s → c ≠ d → 1 ≤ ‖c - d‖
⊢ Finset.card s ∈
    {N |
      ∃ s, Finset.card s = N ∧ (∀ (c : E), c ∈ s → ‖c‖ ≤ 2) ∧ ∀ (c : E), c ∈ s → ∀ (d : E), d ∈ s → c ≠ d → 1 ≤ ‖c - d‖}

tactic: exact ⟨s, rfl, hs, h's⟩
state_before: case h₂
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
s : Finset E
hs : ∀ (c : E), c ∈ s → ‖c‖ ≤ 2
h's : ∀ (c : E), c ∈ s → ∀ (d : E), d ∈ s → c ≠ d → 1 ≤ ‖c - d‖
⊢ ∃ s_1,
    Finset.card s_1 = Finset.card s ∧
      (∀ (c : E), c ∈ s_1 → ‖c‖ ≤ 2) ∧ ∀ (c : E), c ∈ s_1 → ∀ (d : E), d ∈ s_1 → ¬c = d → 1 ≤ ‖c - d‖
Theorem: MeasureTheory.integrableOn_univ
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: rw [IntegrableOn, Measure.restrict_univ]
state_before: α : Type u_1
β : Type ?u.1494574
E : Type u_2
F : Type ?u.1494580
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
⊢ IntegrableOn f univ ↔ Integrable f
Theorem: ContinuousMap.toLp_norm_le
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: rw [toLp_norm_eq_toLp_norm_coe]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.16506630
G : Type ?u.16506633
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedAddCommGroup G
inst✝⁷ : TopologicalSpace α
inst✝⁶ : BorelSpace α
inst✝⁵ : SecondCountableTopologyEither α E
inst✝⁴ : CompactSpace α
inst✝³ : IsFiniteMeasure μ
𝕜 : Type u_3
inst✝² : Fact (1 ≤ p)
inst✝¹ : NontriviallyNormedField 𝕜
inst✝ : NormedSpace 𝕜 E
⊢ ‖toLp p μ 𝕜‖ ≤ ↑(measureUnivNNReal μ ^ (ENNReal.toReal p)⁻¹)

tactic: exact BoundedContinuousFunction.toLp_norm_le μ
state_before: α : Type u_1
E : Type u_2
F : Type ?u.16506630
G : Type ?u.16506633
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : MeasureTheory.Measure α
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedAddCommGroup G
inst✝⁷ : TopologicalSpace α
inst✝⁶ : BorelSpace α
inst✝⁵ : SecondCountableTopologyEither α E
inst✝⁴ : CompactSpace α
inst✝³ : IsFiniteMeasure μ
𝕜 : Type u_3
inst✝² : Fact (1 ≤ p)
inst✝¹ : NontriviallyNormedField 𝕜
inst✝ : NormedSpace 𝕜 E
⊢ ‖BoundedContinuousFunction.toLp p μ 𝕜‖ ≤ ↑(measureUnivNNReal μ ^ (ENNReal.toReal p)⁻¹)
Theorem: Polynomial.eval₂_X_mul
File: Mathlib/Data/Polynomial/Eval.lean

tactic: rw [X_mul, eval₂_mul_X]
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
x : S
inst✝ : Semiring T
⊢ eval₂ f x (X * p) = eval₂ f x p * x
Theorem: Polynomial.X_dvd_iff
File: Mathlib/Data/Polynomial/Div.lean

tactic: rw [hfg, mul_comm, coeff_mul_X_zero]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommSemiring R
f : R[X]
x✝ : X ∣ f
g : R[X]
hfg : f = X * g
⊢ coeff f 0 = 0

tactic: rw [mul_comm, ← add_zero (f.divX * X), ← C_0, ← hf, divX_mul_X_add]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommSemiring R
f : R[X]
hf : coeff f 0 = 0
⊢ f = X * divX f
Theorem: mul_nonpos_of_nonpos_of_nonneg
File: Mathlib/Algebra/Order/Ring/Lemmas.lean

tactic: simpa only [zero_mul] using mul_le_mul_of_nonneg_right ha hb
state_before: α : Type u_1
a b c d : α
inst✝² : MulZeroClass α
inst✝¹ : Preorder α
inst✝ : MulPosMono α
ha : a ≤ 0
hb : 0 ≤ b
⊢ a * b ≤ 0
Theorem: IsPreconnected.intermediate_value₂_eventually₂
File: Mathlib/Topology/Algebra/Order/IntermediateValue.lean

tactic: rw [continuousOn_iff_continuous_restrict] at hf hg
state_before: X : Type u
α : Type v
inst✝⁵ : TopologicalSpace X
inst✝⁴ : LinearOrder α
inst✝³ : TopologicalSpace α
inst✝² : OrderClosedTopology α
s : Set X
hs : IsPreconnected s
l₁ l₂ : Filter X
inst✝¹ : NeBot l₁
inst✝ : NeBot l₂
hl₁ : l₁ ≤ 𝓟 s
hl₂ : l₂ ≤ 𝓟 s
f g : X → α
hf : ContinuousOn f s
hg : ContinuousOn g s
he₁ : f ≤ᶠ[l₁] g
he₂ : g ≤ᶠ[l₂] f
⊢ ∃ x, x ∈ s ∧ f x = g x

tactic: obtain ⟨b, h⟩ :=
  @intermediate_value_univ₂_eventually₂ _ _ _ _ _ _ (Subtype.preconnectedSpace hs) _ _
    (comap_coe_neBot_of_le_principal hl₁) (comap_coe_neBot_of_le_principal hl₂) _ _ hf hg
    (he₁.comap _) (he₂.comap _)
state_before: X : Type u
α : Type v
inst✝⁵ : TopologicalSpace X
inst✝⁴ : LinearOrder α
inst✝³ : TopologicalSpace α
inst✝² : OrderClosedTopology α
s : Set X
hs : IsPreconnected s
l₁ l₂ : Filter X
inst✝¹ : NeBot l₁
inst✝ : NeBot l₂
hl₁ : l₁ ≤ 𝓟 s
hl₂ : l₂ ≤ 𝓟 s
f g : X → α
hf : Continuous (restrict s f)
hg : Continuous (restrict s g)
he₁ : f ≤ᶠ[l₁] g
he₂ : g ≤ᶠ[l₂] f
⊢ ∃ x, x ∈ s ∧ f x = g x

tactic: exact ⟨b, b.prop, h⟩
state_before: case intro
X : Type u
α : Type v
inst✝⁵ : TopologicalSpace X
inst✝⁴ : LinearOrder α
inst✝³ : TopologicalSpace α
inst✝² : OrderClosedTopology α
s : Set X
hs : IsPreconnected s
l₁ l₂ : Filter X
inst✝¹ : NeBot l₁
inst✝ : NeBot l₂
hl₁ : l₁ ≤ 𝓟 s
hl₂ : l₂ ≤ 𝓟 s
f g : X → α
hf : Continuous (restrict s f)
hg : Continuous (restrict s g)
he₁ : f ≤ᶠ[l₁] g
he₂ : g ≤ᶠ[l₂] f
b : ↑s
h : restrict s f b = restrict s g b
⊢ ∃ x, x ∈ s ∧ f x = g x
Theorem: add_one_mul
File: Mathlib/Algebra/Ring/Defs.lean

tactic: rw [add_mul, one_mul]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝² : Add α
inst✝¹ : MulOneClass α
inst✝ : RightDistribClass α
a b : α
⊢ (a + 1) * b = a * b + b
Theorem: MeasureTheory.aecover_restrict_of_ae_imp
File: Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean

tactic: rwa [ae_restrict_iff' hs]
state_before: α : Type u_1
ι : Type u_2
inst✝ : MeasurableSpace α
μ : Measure α
l : Filter ι
s : Set α
φ : ι → Set α
hs : MeasurableSet s
ae_eventually_mem : ∀ᵐ (x : α) ∂μ, x ∈ s → ∀ᶠ (n : ι) in l, x ∈ φ n
measurable : ∀ (n : ι), MeasurableSet (φ n)
⊢ ∀ᵐ (x : α) ∂Measure.restrict μ s, ∀ᶠ (i : ι) in l, x ∈ φ i
Theorem: Int.cast_inj
File: Mathlib/Data/Int/CharZero.lean

tactic: rw [← sub_eq_zero, ← cast_sub, cast_eq_zero, sub_eq_zero]
state_before: α : Type u_1
inst✝¹ : AddGroupWithOne α
inst✝ : CharZero α
m n : ℤ
⊢ ↑m = ↑n ↔ m = n
Theorem: Nat.mod_mod_of_dvd
File: Mathlib/Data/Nat/Basic.lean

tactic: conv =>
rhs
rw [← mod_add_div n k]
state_before: m✝ n✝ k✝ n m k : ℕ
h : m ∣ k
⊢ n % k % m = n % m

tactic: rcases h with ⟨t, rfl⟩
state_before: m✝ n✝ k✝ n m k : ℕ
h : m ∣ k
⊢ n % k % m = (n % k + k * (n / k)) % m

tactic: rw [mul_assoc, add_mul_mod_self_left]
state_before: case intro
m✝ n✝ k n m t : ℕ
⊢ n % (m * t) % m = (n % (m * t) + m * t * (n / (m * t))) % m
Theorem: TopCat.Presheaf.Pushforward.id_hom_app
File: Mathlib/Topology/Sheaves/Presheaf.lean

tactic: induction' U with U
state_before: C : Type u
inst✝ : Category C
X : TopCat
ℱ : Presheaf C X
U : (Opens ↑X)ᵒᵖ
⊢ (id ℱ).hom.app U = ℱ.map (eqToHom (_ : (Functor.op (Opens.map (𝟙 X))).obj U = U))

tactic: apply id_hom_app'
state_before: case h
C : Type u
inst✝ : Category C
X : TopCat
ℱ : Presheaf C X
U : Opens ↑X
⊢ (id ℱ).hom.app U.op = ℱ.map (eqToHom (_ : (Functor.op (Opens.map (𝟙 X))).obj U.op = U.op))
Theorem: CategoryTheory.Sieve.pushforward_comp
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: simpa
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
S R✝ : Sieve X
f : Y ⟶ X
g : Z ⟶ Y
R : Sieve Z
W : C
h : W ⟶ X
x✝ : (pushforward (g ≫ f) R).arrows h
f₁ : W ⟶ Z
hq : f₁ ≫ g ≫ f = h
hf₁ : R.arrows f₁
⊢ (f₁ ≫ g) ≫ f = h

tactic: rw [← Category.assoc, hR]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
S R✝ : Sieve X
f : Y ⟶ X
g : Z ⟶ Y
R : Sieve Z
W : C
h : W ⟶ X
x✝ : (pushforward f (pushforward g R)).arrows h
y : W ⟶ Y
hy : y ≫ f = h
z : W ⟶ Z
hR : z ≫ g = y
hz : R.arrows z
⊢ z ≫ g ≫ f = h ∧ R.arrows z

tactic: tauto
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
S R✝ : Sieve X
f : Y ⟶ X
g : Z ⟶ Y
R : Sieve Z
W : C
h : W ⟶ X
x✝ : (pushforward f (pushforward g R)).arrows h
y : W ⟶ Y
hy : y ≫ f = h
z : W ⟶ Z
hR : z ≫ g = y
hz : R.arrows z
⊢ y ≫ f = h ∧ R.arrows z
Theorem: MeasureTheory.set_integral_mono_on
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: simp [hs, EventuallyLE, eventually_inf_principal, ae_of_all _ h]
state_before: α : Type u_1
β : Type ?u.283976
E : Type ?u.283979
F : Type ?u.283982
inst✝ : MeasurableSpace α
μ : Measure α
f g : α → ℝ
s t : Set α
hf : IntegrableOn f s
hg : IntegrableOn g s
hs : MeasurableSet s
h : ∀ (x : α), x ∈ s → f x ≤ g x
⊢ (fun a => f a) ≤ᵐ[Measure.restrict μ s] fun a => g a
Theorem: Set.indicator_mul_left
File: Mathlib/Algebra/IndicatorFunction.lean

tactic: simp only [indicator]
state_before: α : Type u_1
β : Type ?u.120510
ι : Type ?u.120513
M : Type u_2
N : Type ?u.120519
inst✝ : MulZeroClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
⊢ indicator s (fun a => f a * g a) a = indicator s f a * g a

tactic: split_ifs
state_before: α : Type u_1
β : Type ?u.120510
ι : Type ?u.120513
M : Type u_2
N : Type ?u.120519
inst✝ : MulZeroClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
⊢ (if a ∈ s then f a * g a else 0) = (if a ∈ s then f a else 0) * g a

tactic: rw [zero_mul]
state_before: case inr
α : Type u_1
β : Type ?u.120510
ι : Type ?u.120513
M : Type u_2
N : Type ?u.120519
inst✝ : MulZeroClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
h✝ : ¬a ∈ s
⊢ 0 = 0 * g a

tactic: rfl
state_before: case inl
α : Type u_1
β : Type ?u.120510
ι : Type ?u.120513
M : Type u_2
N : Type ?u.120519
inst✝ : MulZeroClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
h✝ : a ∈ s
⊢ f a * g a = f a * g a
Theorem: Multiset.Ico_add_Ico_eq_Ico
File: Mathlib/Data/Multiset/LocallyFinite.lean

tactic: rw [add_eq_union_iff_disjoint.2 (Ico_disjoint_Ico le_rfl), Ico, Ico, Ico, ← Finset.union_val,
  Finset.Ico_union_Ico_eq_Ico hab hbc]
state_before: α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ c✝ d a b c : α
hab : a ≤ b
hbc : b ≤ c
⊢ Ico a b + Ico b c = Ico a c
Theorem: List.rotate_nil
File: Mathlib/Data/List/Rotate.lean

tactic: simp [rotate]
state_before: α : Type u
n : ℕ
⊢ rotate [] n = []
Theorem: List.ext_get
File: Std/Data/List/Lemmas.lean

tactic: rw [get?_eq_get, get?_eq_get, h n h₁ (by rwa [← hl])]
state_before: α : Type u_1
l₁ l₂ : List α
hl : length l₁ = length l₂
h :
  ∀ (n : Nat) (h₁ : n < length l₁) (h₂ : n < length l₂),
    get l₁ { val := n, isLt := h₁ } = get l₂ { val := n, isLt := h₂ }
n : Nat
h₁ : n < length l₁
⊢ get? l₁ n = get? l₂ n

tactic: rwa [← hl]
state_before: α : Type u_1
l₁ l₂ : List α
hl : length l₁ = length l₂
h :
  ∀ (n : Nat) (h₁ : n < length l₁) (h₂ : n < length l₂),
    get l₁ { val := n, isLt := h₁ } = get l₂ { val := n, isLt := h₂ }
n : Nat
h₁ : n < length l₁
⊢ n < length l₂

tactic: have h₁ := Nat.le_of_not_lt h₁
state_before: α : Type u_1
l₁ l₂ : List α
hl : length l₁ = length l₂
h :
  ∀ (n : Nat) (h₁ : n < length l₁) (h₂ : n < length l₂),
    get l₁ { val := n, isLt := h₁ } = get l₂ { val := n, isLt := h₂ }
n : Nat
h₁ : ¬n < length l₁
⊢ get? l₁ n = get? l₂ n

tactic: rw [get?_len_le h₁, get?_len_le]
state_before: α : Type u_1
l₁ l₂ : List α
hl : length l₁ = length l₂
h :
  ∀ (n : Nat) (h₁ : n < length l₁) (h₂ : n < length l₂),
    get l₁ { val := n, isLt := h₁ } = get l₂ { val := n, isLt := h₂ }
n : Nat
h₁✝ : ¬n < length l₁
h₁ : length l₁ ≤ n
⊢ get? l₁ n = get? l₂ n

tactic: rwa [← hl]
state_before: α : Type u_1
l₁ l₂ : List α
hl : length l₁ = length l₂
h :
  ∀ (n : Nat) (h₁ : n < length l₁) (h₂ : n < length l₂),
    get l₁ { val := n, isLt := h₁ } = get l₂ { val := n, isLt := h₂ }
n : Nat
h₁✝ : ¬n < length l₁
h₁ : length l₁ ≤ n
⊢ length l₂ ≤ n
Theorem: Filter.frequently_lt_of_lt_limsup
File: Mathlib/Order/LiminfLimsup.lean

tactic: contrapose! h
state_before: α✝ : Type ?u.192359
β✝ : Type ?u.192362
γ : Type ?u.192365
ι : Type ?u.192368
α : Type u_1
β : Type u_2
inst✝ : ConditionallyCompleteLinearOrder β
f : Filter α
u : α → β
b : β
hu : autoParam (IsCoboundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝
h : b < limsup u f
⊢ ∃ᶠ (x : α) in f, b < u x

tactic: apply limsSup_le_of_le hu
state_before: α✝ : Type ?u.192359
β✝ : Type ?u.192362
γ : Type ?u.192365
ι : Type ?u.192368
α : Type u_1
β : Type u_2
inst✝ : ConditionallyCompleteLinearOrder β
f : Filter α
u : α → β
b : β
hu : autoParam (IsCoboundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝
h : ¬∃ᶠ (x : α) in f, b < u x
⊢ limsup u f ≤ b

tactic: simpa using h
state_before: α✝ : Type ?u.192359
β✝ : Type ?u.192362
γ : Type ?u.192365
ι : Type ?u.192368
α : Type u_1
β : Type u_2
inst✝ : ConditionallyCompleteLinearOrder β
f : Filter α
u : α → β
b : β
hu : autoParam (IsCoboundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝
h : ¬∃ᶠ (x : α) in f, b < u x
⊢ ∀ᶠ (n : β) in map u f, n ≤ b
Theorem: Stream'.WSeq.join_ret
File: Mathlib/Data/Seq/WSeq.lean

tactic: simp [ret]
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
⊢ join (ret s) ~ʷ s

tactic: apply think_equiv
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
⊢ think s ~ʷ s
Theorem: Finset.Icc_ssubset_Icc_left
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← coe_ssubset, coe_Icc, coe_Icc]
state_before: ι : Type ?u.26888
α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
hI : a₂ ≤ b₂
ha : a₂ < a₁
hb : b₁ ≤ b₂
⊢ Icc a₁ b₁ ⊂ Icc a₂ b₂

tactic: exact Set.Icc_ssubset_Icc_left hI ha hb
state_before: ι : Type ?u.26888
α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
hI : a₂ ≤ b₂
ha : a₂ < a₁
hb : b₁ ≤ b₂
⊢ Set.Icc a₁ b₁ ⊂ Set.Icc a₂ b₂
Theorem: ENNReal.toReal_max
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp only [h, (ENNReal.toReal_le_toReal hr hp).2 h, max_eq_right]
state_before: α : Type ?u.801082
β : Type ?u.801085
a b c d : ℝ≥0∞
r p q : ℝ≥0
hr : a ≠ ⊤
hp : b ≠ ⊤
h : a ≤ b
⊢ ENNReal.toReal (max a b) = max (ENNReal.toReal a) (ENNReal.toReal b)

tactic: simp only [h, (ENNReal.toReal_le_toReal hp hr).2 h, max_eq_left]
state_before: α : Type ?u.801082
β : Type ?u.801085
a b c d : ℝ≥0∞
r p q : ℝ≥0
hr : a ≠ ⊤
hp : b ≠ ⊤
h : b ≤ a
⊢ ENNReal.toReal (max a b) = max (ENNReal.toReal a) (ENNReal.toReal b)
Theorem: Equiv.Set.image_symm_preimage
File: Mathlib/Logic/Equiv/Set.lean

tactic: ext ⟨b, a, has, rfl⟩
state_before: α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
f : α → β
hf : Injective f
u s : Set α
⊢ (fun x => ↑(↑(Set.image f s hf).symm x)) ⁻¹' u = Subtype.val ⁻¹' (f '' u)

tactic: have : ∀ h : ∃ a', a' ∈ s ∧ a' = a, Classical.choose h = a := fun h => (Classical.choose_spec h).2
state_before: case h.mk.intro.intro
α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
f : α → β
hf : Injective f
u s : Set α
a : α
has : a ∈ s
⊢ { val := f a, property := (_ : ∃ a_1, a_1 ∈ s ∧ f a_1 = f a) } ∈ (fun x => ↑(↑(Set.image f s hf).symm x)) ⁻¹' u ↔
    { val := f a, property := (_ : ∃ a_1, a_1 ∈ s ∧ f a_1 = f a) } ∈ Subtype.val ⁻¹' (f '' u)

tactic: simp [Equiv.Set.image, Equiv.Set.imageOfInjOn, hf.eq_iff, this]
state_before: case h.mk.intro.intro
α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
f : α → β
hf : Injective f
u s : Set α
a : α
has : a ∈ s
this : ∀ (h : ∃ a', a' ∈ s ∧ a' = a), Classical.choose h = a
⊢ { val := f a, property := (_ : ∃ a_1, a_1 ∈ s ∧ f a_1 = f a) } ∈ (fun x => ↑(↑(Set.image f s hf).symm x)) ⁻¹' u ↔
    { val := f a, property := (_ : ∃ a_1, a_1 ∈ s ∧ f a_1 = f a) } ∈ Subtype.val ⁻¹' (f '' u)
Theorem: CategoryTheory.Functor.map_comp_hEq'
File: Mathlib/CategoryTheory/EqToHom.lean

tactic: rw [Functor.hext hobj fun _ _ => hmap]
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F G : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
hobj : ∀ (X : C), F.obj X = G.obj X
hmap : ∀ {X Y : C} (f : X ⟶ Y), HEq (F.map f) (G.map f)
⊢ HEq (F.map (f ≫ g)) (G.map (f ≫ g))
Theorem: HasStrictDerivAt.scomp
File: Mathlib/Analysis/Calculus/Deriv/Comp.lean

tactic: simpa using ((hg.restrictScalars 𝕜).comp x hh).hasStrictDerivAt
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_1
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
s' t' : Set 𝕜'
h : 𝕜 → 𝕜'
h₁ : 𝕜 → 𝕜
h₂ : 𝕜' → 𝕜'
h' h₂' : 𝕜'
h₁' : 𝕜
g₁ : 𝕜' → F
g₁' : F
L' : Filter 𝕜'
hg : HasStrictDerivAt g₁ g₁' (h x)
hh : HasStrictDerivAt h h' x
⊢ HasStrictDerivAt (g₁ ∘ h) (h' • g₁') x
Theorem: ManyOneDegree.le_trans
File: Mathlib/Computability/Reduce.lean

tactic: induction d₁ using ManyOneDegree.ind_on
state_before: α : Type u
inst✝⁵ : Primcodable α
inst✝⁴ : Inhabited α
β : Type v
inst✝³ : Primcodable β
inst✝² : Inhabited β
γ : Type w
inst✝¹ : Primcodable γ
inst✝ : Inhabited γ
d₁ d₂ d₃ : ManyOneDegree
⊢ d₁ ≤ d₂ → d₂ ≤ d₃ → d₁ ≤ d₃

tactic: induction d₂ using ManyOneDegree.ind_on
state_before: case h
α : Type u
inst✝⁵ : Primcodable α
inst✝⁴ : Inhabited α
β : Type v
inst✝³ : Primcodable β
inst✝² : Inhabited β
γ : Type w
inst✝¹ : Primcodable γ
inst✝ : Inhabited γ
d₂ d₃ : ManyOneDegree
p✝ : Set ℕ
⊢ of p✝ ≤ d₂ → d₂ ≤ d₃ → of p✝ ≤ d₃

tactic: induction d₃ using ManyOneDegree.ind_on
state_before: case h.h
α : Type u
inst✝⁵ : Primcodable α
inst✝⁴ : Inhabited α
β : Type v
inst✝³ : Primcodable β
inst✝² : Inhabited β
γ : Type w
inst✝¹ : Primcodable γ
inst✝ : Inhabited γ
d₃ : ManyOneDegree
p✝¹ p✝ : Set ℕ
⊢ of p✝¹ ≤ of p✝ → of p✝ ≤ d₃ → of p✝¹ ≤ d₃

tactic: apply ManyOneReducible.trans
state_before: case h.h.h
α : Type u
inst✝⁵ : Primcodable α
inst✝⁴ : Inhabited α
β : Type v
inst✝³ : Primcodable β
inst✝² : Inhabited β
γ : Type w
inst✝¹ : Primcodable γ
inst✝ : Inhabited γ
p✝² p✝¹ p✝ : Set ℕ
⊢ of p✝² ≤ of p✝¹ → of p✝¹ ≤ of p✝ → of p✝² ≤ of p✝
Theorem: SimpleGraph.Walk.mem_edges_toSubgraph
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p <;> simp [*]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : Walk G u v
e : Sym2 V
⊢ e ∈ Subgraph.edgeSet (Walk.toSubgraph p) ↔ e ∈ edges p
Theorem: Substring.Valid.foldr
File: Std/Data/String/Lemmas.lean

tactic: simp [h.foldr, h.toString]
state_before: α : Type u_1
f : Char → α → α
init : α
x✝ : Substring
h✝ : Valid x✝
w✝² w✝¹ w✝ : List Char
h : ValidFor w✝² w✝¹ w✝ x✝
⊢ Substring.foldr f init x✝ = List.foldr f init (toString x✝).data
Theorem: Basis.orientation_eq_or_eq_neg
File: Mathlib/LinearAlgebra/Orientation.lean

tactic: induction' x using Module.Ray.ind with x hx
state_before: R : Type u_2
inst✝⁴ : LinearOrderedCommRing R
M : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
ι : Type u_1
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
e : Basis ι R M
x : Orientation R M ι
⊢ x = Basis.orientation e ∨ x = -Basis.orientation e

tactic: rw [← x.map_basis_ne_zero_iff e] at hx
state_before: case h
R : Type u_2
inst✝⁴ : LinearOrderedCommRing R
M : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
ι : Type u_1
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
e : Basis ι R M
x : AlternatingMap R M R ι
hx : x ≠ 0
⊢ rayOfNeZero R x hx = Basis.orientation e ∨ rayOfNeZero R x hx = -Basis.orientation e

tactic: rwa [Basis.orientation, ray_eq_iff, neg_rayOfNeZero, ray_eq_iff, x.eq_smul_basis_det e,
  sameRay_neg_smul_left_iff_of_ne e.det_ne_zero hx, sameRay_smul_left_iff_of_ne e.det_ne_zero hx,
  lt_or_lt_iff_ne, ne_comm]
state_before: case h
R : Type u_2
inst✝⁴ : LinearOrderedCommRing R
M : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
ι : Type u_1
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
e : Basis ι R M
x : AlternatingMap R M R ι
hx✝ : x ≠ 0
hx : ↑x ↑e ≠ 0
⊢ rayOfNeZero R x hx✝ = Basis.orientation e ∨ rayOfNeZero R x hx✝ = -Basis.orientation e
Theorem: ENNReal.rpow_eq_top_iff
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: cases' x with x
state_before: x : ℝ≥0∞
y : ℝ
⊢ x ^ y = ⊤ ↔ x = 0 ∧ y < 0 ∨ x = ⊤ ∧ 0 < y

tactic: rcases lt_trichotomy y 0 with (H | H | H) <;>
  simp [H, top_rpow_of_neg, top_rpow_of_pos, le_of_lt]
state_before: case none
y : ℝ
⊢ none ^ y = ⊤ ↔ none = 0 ∧ y < 0 ∨ none = ⊤ ∧ 0 < y

tactic: by_cases h : x = 0
state_before: case some
y : ℝ
x : ℝ≥0
⊢ Option.some x ^ y = ⊤ ↔ Option.some x = 0 ∧ y < 0 ∨ Option.some x = ⊤ ∧ 0 < y

tactic: rcases lt_trichotomy y 0 with (H | H | H) <;>
  simp [h, H, zero_rpow_of_neg, zero_rpow_of_pos, le_of_lt]
state_before: case pos
y : ℝ
x : ℝ≥0
h : x = 0
⊢ Option.some x ^ y = ⊤ ↔ Option.some x = 0 ∧ y < 0 ∨ Option.some x = ⊤ ∧ 0 < y

tactic: simp [coe_rpow_of_ne_zero h, h]
state_before: case neg
y : ℝ
x : ℝ≥0
h : ¬x = 0
⊢ Option.some x ^ y = ⊤ ↔ Option.some x = 0 ∧ y < 0 ∨ Option.some x = ⊤ ∧ 0 < y
Theorem: list_reverse'
File: Mathlib/Computability/Primrec.lean

tactic: induction l <;> simp [*, List.reverseAux]
state_before: α : Type ?u.194459
β : Type u_1
σ : Type ?u.194465
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
H : Nat.Primrec fun n => encode (decode n)
this : Primcodable (List β) := prim H
l : List β
⊢ ∀ (r : List β), List.foldl (fun s b => b :: s) r l = List.reverseAux l r
Theorem: Finset.insert_compl_self
File: Mathlib/Data/Fintype/Basic.lean

tactic: rw [← compl_erase, erase_singleton, compl_empty]
state_before: α : Type u_1
β : Type ?u.12912
γ : Type ?u.12915
inst✝¹ : Fintype α
s t : Finset α
inst✝ : DecidableEq α
a x : α
⊢ insert x ({x}ᶜ) = univ
Theorem: PartialOrder.toPreorder_injective
File: Mathlib/Order/Basic.lean

tactic: cases A
state_before: ι : Type ?u.12814
α✝ : Type u
β : Type v
γ : Type w
π : ι → Type ?u.12825
r : α✝ → α✝ → Prop
α : Type u_1
A B : PartialOrder α
h : toPreorder = toPreorder
⊢ A = B

tactic: cases B
state_before: case mk
ι : Type ?u.12814
α✝ : Type u
β : Type v
γ : Type w
π : ι → Type ?u.12825
r : α✝ → α✝ → Prop
α : Type u_1
B : PartialOrder α
toPreorder✝ : Preorder α
le_antisymm✝ : ∀ (a b : α), a ≤ b → b ≤ a → a = b
h : toPreorder = toPreorder
⊢ mk le_antisymm✝ = B

tactic: cases h
state_before: case mk.mk
ι : Type ?u.12814
α✝ : Type u
β : Type v
γ : Type w
π : ι → Type ?u.12825
r : α✝ → α✝ → Prop
α : Type u_1
toPreorder✝¹ : Preorder α
le_antisymm✝¹ : ∀ (a b : α), a ≤ b → b ≤ a → a = b
toPreorder✝ : Preorder α
le_antisymm✝ : ∀ (a b : α), a ≤ b → b ≤ a → a = b
h : toPreorder = toPreorder
⊢ mk le_antisymm✝¹ = mk le_antisymm✝

tactic: congr
state_before: case mk.mk.refl
ι : Type ?u.12814
α✝ : Type u
β : Type v
γ : Type w
π : ι → Type ?u.12825
r : α✝ → α✝ → Prop
α : Type u_1
toPreorder✝ : Preorder α
le_antisymm✝¹ le_antisymm✝ : ∀ (a b : α), a ≤ b → b ≤ a → a = b
⊢ mk le_antisymm✝¹ = mk le_antisymm✝