tasksource/leandojo huggingface dataset:
Theorem: List.mem_of_nextOr_ne
File: Mathlib/Data/List/Cycle.lean

tactic: induction' xs with y ys IH
state_before: α : Type u_1
inst✝ : DecidableEq α
xs : List α
x d : α
h : nextOr xs x d ≠ d
⊢ x ∈ xs

tactic: cases' ys with z zs
state_before: case cons
α : Type u_1
inst✝ : DecidableEq α
xs : List α
x d : α
h✝ : nextOr xs x d ≠ d
y : α
ys : List α
IH : nextOr ys x d ≠ d → x ∈ ys
h : nextOr (y :: ys) x d ≠ d
⊢ x ∈ y :: ys

tactic: simp at h
state_before: case nil
α : Type u_1
inst✝ : DecidableEq α
xs : List α
x d : α
h✝ : nextOr xs x d ≠ d
h : nextOr [] x d ≠ d
⊢ x ∈ []

tactic: simp at h
state_before: case cons.nil
α : Type u_1
inst✝ : DecidableEq α
xs : List α
x d : α
h✝ : nextOr xs x d ≠ d
y : α
IH : nextOr [] x d ≠ d → x ∈ []
h : nextOr [y] x d ≠ d
⊢ x ∈ [y]

tactic: by_cases hx : x = y
state_before: case cons.cons
α : Type u_1
inst✝ : DecidableEq α
xs : List α
x d : α
h✝ : nextOr xs x d ≠ d
y z : α
zs : List α
IH : nextOr (z :: zs) x d ≠ d → x ∈ z :: zs
h : nextOr (y :: z :: zs) x d ≠ d
⊢ x ∈ y :: z :: zs

tactic: simp [hx]
state_before: case pos
α : Type u_1
inst✝ : DecidableEq α
xs : List α
x d : α
h✝ : nextOr xs x d ≠ d
y z : α
zs : List α
IH : nextOr (z :: zs) x d ≠ d → x ∈ z :: zs
h : nextOr (y :: z :: zs) x d ≠ d
hx : x = y
⊢ x ∈ y :: z :: zs

tactic: rw [nextOr_cons_of_ne _ _ _ _ hx] at h
state_before: case neg
α : Type u_1
inst✝ : DecidableEq α
xs : List α
x d : α
h✝ : nextOr xs x d ≠ d
y z : α
zs : List α
IH : nextOr (z :: zs) x d ≠ d → x ∈ z :: zs
h : nextOr (y :: z :: zs) x d ≠ d
hx : ¬x = y
⊢ x ∈ y :: z :: zs

tactic: simpa [hx] using IH h
state_before: case neg
α : Type u_1
inst✝ : DecidableEq α
xs : List α
x d : α
h✝ : nextOr xs x d ≠ d
y z : α
zs : List α
IH : nextOr (z :: zs) x d ≠ d → x ∈ z :: zs
h : nextOr (z :: zs) x d ≠ d
hx : ¬x = y
⊢ x ∈ y :: z :: zs
Theorem: CategoryTheory.Limits.coequalizer.isoTargetOfSelf_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

tactic: simp
state_before: C : Type u
inst✝ : Category C
X Y : C
f g : X ⟶ Y
⊢ f ≫ 𝟙 Y = f ≫ 𝟙 Y

tactic: apply coequalizer.hom_ext
state_before: C : Type u
inst✝ : Category C
X Y : C
f g : X ⟶ Y
⊢ (isoTargetOfSelf f).hom = desc (𝟙 Y) (_ : f ≫ 𝟙 Y = f ≫ 𝟙 Y)

tactic: simp [coequalizer.isoTargetOfSelf]
state_before: case h
C : Type u
inst✝ : Category C
X Y : C
f g : X ⟶ Y
⊢ π f f ≫ (isoTargetOfSelf f).hom = π f f ≫ desc (𝟙 Y) (_ : f ≫ 𝟙 Y = f ≫ 𝟙 Y)
Theorem: Set.image_const_add_Iio
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [add_comm]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => a + x) '' Iio b = Iio (a + b)
Theorem: Sigma.isConnected_iff
File: Mathlib/Topology/Connected.lean

tactic: refine' ⟨fun hs => _, _⟩
state_before: α : Type u
β : Type v
ι : Type u_2
π : ι → Type u_1
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : (i : ι) → TopologicalSpace (π i)
s : Set ((i : ι) × π i)
⊢ IsConnected s ↔ ∃ i t, IsConnected t ∧ s = mk i '' t

tactic: obtain ⟨⟨i, x⟩, hx⟩ := hs.nonempty
state_before: case refine'_1
α : Type u
β : Type v
ι : Type u_2
π : ι → Type u_1
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : (i : ι) → TopologicalSpace (π i)
s : Set ((i : ι) × π i)
hs : IsConnected s
⊢ ∃ i t, IsConnected t ∧ s = mk i '' t

tactic: have : s ⊆ range (Sigma.mk i) :=
  hs.isPreconnected.subset_clopen isClopen_range_sigmaMk ⟨⟨i, x⟩, hx, x, rfl⟩
state_before: case refine'_1.intro.mk
α : Type u
β : Type v
ι : Type u_2
π : ι → Type u_1
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : (i : ι) → TopologicalSpace (π i)
s : Set ((i : ι) × π i)
hs : IsConnected s
i : ι
x : π i
hx : { fst := i, snd := x } ∈ s
⊢ ∃ i t, IsConnected t ∧ s = mk i '' t

tactic: exact ⟨i, Sigma.mk i ⁻¹' s, hs.preimage_of_openMap sigma_mk_injective isOpenMap_sigmaMk this,
  (Set.image_preimage_eq_of_subset this).symm⟩
state_before: case refine'_1.intro.mk
α : Type u
β : Type v
ι : Type u_2
π : ι → Type u_1
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : (i : ι) → TopologicalSpace (π i)
s : Set ((i : ι) × π i)
hs : IsConnected s
i : ι
x : π i
hx : { fst := i, snd := x } ∈ s
this : s ⊆ range (mk i)
⊢ ∃ i t, IsConnected t ∧ s = mk i '' t

tactic: rintro ⟨i, t, ht, rfl⟩
state_before: case refine'_2
α : Type u
β : Type v
ι : Type u_2
π : ι → Type u_1
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : (i : ι) → TopologicalSpace (π i)
s : Set ((i : ι) × π i)
⊢ (∃ i t, IsConnected t ∧ s = mk i '' t) → IsConnected s

tactic: exact ht.image _ continuous_sigmaMk.continuousOn
state_before: case refine'_2.intro.intro.intro
α : Type u
β : Type v
ι : Type u_2
π : ι → Type u_1
inst✝¹ : TopologicalSpace α
s t✝ u v : Set α
inst✝ : (i : ι) → TopologicalSpace (π i)
i : ι
t : Set (π i)
ht : IsConnected t
⊢ IsConnected (mk i '' t)
Theorem: Complex.continuous_sinh
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: change Continuous fun z => (exp z - exp (-z)) / 2
state_before: ⊢ Continuous sinh

tactic: continuity
state_before: ⊢ Continuous fun z => (exp z - exp (-z)) / 2
Theorem: Nat.WithBot.add_eq_one_iff
File: Mathlib/Data/Nat/WithBot.lean

tactic: rcases n, m with ⟨_ | _, _ | _⟩
state_before: n m : WithBot ℕ
⊢ n + m = 1 ↔ n = 0 ∧ m = 1 ∨ n = 1 ∧ m = 0

tactic: any_goals refine' ⟨fun h => Option.noConfusion h, fun h => _⟩; aesop
state_before: case none.none

⊢ none + none = 1 ↔ none = 0 ∧ none = 1 ∨ none = 1 ∧ none = 0

case none.some
val✝ : ℕ
⊢ none + some val✝ = 1 ↔ none = 0 ∧ some val✝ = 1 ∨ none = 1 ∧ some val✝ = 0

case some.none
val✝ : ℕ
⊢ some val✝ + none = 1 ↔ some val✝ = 0 ∧ none = 1 ∨ some val✝ = 1 ∧ none = 0

case some.some
val✝¹ val✝ : ℕ
⊢ some val✝¹ + some val✝ = 1 ↔ some val✝¹ = 0 ∧ some val✝ = 1 ∨ some val✝¹ = 1 ∧ some val✝ = 0

tactic: repeat' erw [WithBot.coe_eq_coe]
state_before: case some.some
val✝¹ val✝ : ℕ
⊢ some val✝¹ + some val✝ = 1 ↔ some val✝¹ = 0 ∧ some val✝ = 1 ∨ some val✝¹ = 1 ∧ some val✝ = 0

tactic: exact Nat.add_eq_one_iff
state_before: case some.some
val✝¹ val✝ : ℕ
⊢ (fun x x_1 => x + x_1) val✝¹ val✝ = 1 ↔ val✝¹ = 0 ∧ val✝ = 1 ∨ val✝¹ = 1 ∧ val✝ = 0

tactic: refine' ⟨fun h => Option.noConfusion h, fun h => _⟩
state_before: case some.some
val✝¹ val✝ : ℕ
⊢ some val✝¹ + some val✝ = 1 ↔ some val✝¹ = 0 ∧ some val✝ = 1 ∨ some val✝¹ = 1 ∧ some val✝ = 0

tactic: aesop
state_before: case some.none
val✝ : ℕ
h : some val✝ = 0 ∧ none = 1 ∨ some val✝ = 1 ∧ none = 0
⊢ some val✝ + none = 1

tactic: erw [WithBot.coe_eq_coe]
state_before: case some.some
val✝¹ val✝ : ℕ
⊢ (fun x x_1 => x + x_1) val✝¹ val✝ = 1 ↔ val✝¹ = 0 ∧ val✝ = 1 ∨ val✝¹ = 1 ∧ val✝ = 0
Theorem: Algebra.adjoin_singleton_eq_range_aeval
File: Mathlib/Data/Polynomial/AlgebraMap.lean

tactic: rw [← Algebra.map_top, ← adjoin_X, AlgHom.map_adjoin, Set.image_singleton, aeval_X]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
A' : Type ?u.1269188
B' : Type ?u.1269191
a b : R
n : ℕ
inst✝⁶ : CommSemiring A'
inst✝⁵ : Semiring B'
inst✝⁴ : CommSemiring R
p q : R[X]
inst✝³ : Semiring A
inst✝² : Algebra R A
B : Type ?u.1269404
inst✝¹ : Semiring B
inst✝ : Algebra R B
x✝ x : A
⊢ Algebra.adjoin R {x} = AlgHom.range (aeval x)
Theorem: LieSubalgebra.lieSpan_mono
File: Mathlib/Algebra/Lie/Subalgebra.lean

tactic: rw [lieSpan_le]
state_before: R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s t : Set L
h : s ⊆ t
⊢ lieSpan R L s ≤ lieSpan R L t

tactic: exact Set.Subset.trans h subset_lieSpan
state_before: R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s t : Set L
h : s ⊆ t
⊢ s ⊆ ↑(lieSpan R L t)
Theorem: Polynomial.degree_pow'
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [pow_zero, ← C_1] at *
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.684865
h : leadingCoeff p ^ 0 ≠ 0
⊢ degree (p ^ 0) = 0 • degree p

tactic: rw [degree_C h, zero_nsmul]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.684865
h : 1 ≠ 0
⊢ degree (↑C 1) = 0 • degree p

tactic: have h₁ : leadingCoeff p ^ n ≠ 0 := fun h₁ => h <| by rw [pow_succ, h₁, mul_zero]
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.684865
n : ℕ
h : leadingCoeff p ^ (n + 1) ≠ 0
⊢ degree (p ^ (n + 1)) = (n + 1) • degree p

tactic: have h₂ : leadingCoeff p * leadingCoeff (p ^ n) ≠ 0 := by
  rwa [pow_succ, ← leadingCoeff_pow' h₁] at h
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.684865
n : ℕ
h : leadingCoeff p ^ (n + 1) ≠ 0
h₁ : leadingCoeff p ^ n ≠ 0
⊢ degree (p ^ (n + 1)) = (n + 1) • degree p

tactic: rw [pow_succ, degree_mul' h₂, succ_nsmul, degree_pow' h₁]
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.684865
n : ℕ
h : leadingCoeff p ^ (n + 1) ≠ 0
h₁ : leadingCoeff p ^ n ≠ 0
h₂ : leadingCoeff p * leadingCoeff (p ^ n) ≠ 0
⊢ degree (p ^ (n + 1)) = (n + 1) • degree p

tactic: rw [pow_succ, h₁, mul_zero]
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.684865
n : ℕ
h : leadingCoeff p ^ (n + 1) ≠ 0
h₁ : leadingCoeff p ^ n = 0
⊢ leadingCoeff p ^ (n + 1) = 0

tactic: rwa [pow_succ, ← leadingCoeff_pow' h₁] at h
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.684865
n : ℕ
h : leadingCoeff p ^ (n + 1) ≠ 0
h₁ : leadingCoeff p ^ n ≠ 0
⊢ leadingCoeff p * leadingCoeff (p ^ n) ≠ 0
Theorem: StructureGroupoid.LocalInvariantProp.liftPropWithinAt_of_liftPropAt_of_mem_nhds
File: Mathlib/Geometry/Manifold/LocalInvariantProperties.lean

tactic: rwa [← univ_inter s, hG.liftPropWithinAt_inter hs]
state_before: H : Type u_1
M : Type u_2
H' : Type u_3
M' : Type u_4
X : Type ?u.37448
inst✝⁶ : TopologicalSpace H
inst✝⁵ : TopologicalSpace M
inst✝⁴ : ChartedSpace H M
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
inst✝¹ : ChartedSpace H' M'
inst✝ : TopologicalSpace X
G : StructureGroupoid H
G' : StructureGroupoid H'
e e' : LocalHomeomorph M H
f f' : LocalHomeomorph M' H'
P : (H → H') → Set H → H → Prop
g g' : M → M'
s t : Set M
x : M
Q : (H → H) → Set H → H → Prop
hG : LocalInvariantProp G G' P
h : LiftPropAt P g x
hs : s ∈ 𝓝 x
⊢ LiftPropWithinAt P g s x
Theorem: CompleteLattice.bot_continuous
File: Mathlib/Order/OmegaCompletePartialOrder.lean

tactic: rw [← sSup_empty]
state_before: α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
⊢ Continuous ⊥

tactic: exact sSup_continuous _ fun f hf => hf.elim
state_before: α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
⊢ Continuous (sSup ∅)
Theorem: ENNReal.essSup_liminf_le
File: Mathlib/MeasureTheory/Function/EssSup.lean

tactic: simp_rw [essSup]
state_before: α : Type u_2
β : Type ?u.5631541
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
f✝ : α → ℝ≥0∞
ι : Type u_1
inst✝¹ : Countable ι
inst✝ : LinearOrder ι
f : ι → α → ℝ≥0∞
⊢ essSup (fun x => liminf (fun n => f n x) atTop) μ ≤ liminf (fun n => essSup (fun x => f n x) μ) atTop

tactic: exact ENNReal.limsup_liminf_le_liminf_limsup fun a b => f b a
state_before: α : Type u_2
β : Type ?u.5631541
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
f✝ : α → ℝ≥0∞
ι : Type u_1
inst✝¹ : Countable ι
inst✝ : LinearOrder ι
f : ι → α → ℝ≥0∞
⊢ limsup (fun x => liminf (fun n => f n x) atTop) (Measure.ae μ) ≤
    liminf (fun n => limsup (fun x => f n x) (Measure.ae μ)) atTop
Theorem: Finset.prod_dvd_of_coprime
File: Mathlib/RingTheory/Coprime/Lemmas.lean

tactic: intro a r har ih Hs Hs1
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
⊢ ∀ ⦃a : I⦄ {s_1 : Finset I},
    ¬a ∈ s_1 →
      (Set.Pairwise (↑s_1) (IsCoprime on s) → (∀ (i : I), i ∈ s_1 → s i ∣ z) → ∏ x in s_1, s x ∣ z) →
        Set.Pairwise (↑(insert a s_1)) (IsCoprime on s) →
          (∀ (i : I), i ∈ insert a s_1 → s i ∣ z) → ∏ x in insert a s_1, s x ∣ z

tactic: rw [Finset.prod_insert har]
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
a : I
r : Finset I
har : ¬a ∈ r
ih : Set.Pairwise (↑r) (IsCoprime on s) → (∀ (i : I), i ∈ r → s i ∣ z) → ∏ x in r, s x ∣ z
Hs : Set.Pairwise (↑(insert a r)) (IsCoprime on s)
Hs1 : ∀ (i : I), i ∈ insert a r → s i ∣ z
⊢ ∏ x in insert a r, s x ∣ z

tactic: have aux1 : a ∈ (↑(insert a r) : Set I) := Finset.mem_insert_self a r
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
a : I
r : Finset I
har : ¬a ∈ r
ih : Set.Pairwise (↑r) (IsCoprime on s) → (∀ (i : I), i ∈ r → s i ∣ z) → ∏ x in r, s x ∣ z
Hs : Set.Pairwise (↑(insert a r)) (IsCoprime on s)
Hs1 : ∀ (i : I), i ∈ insert a r → s i ∣ z
⊢ s a * ∏ x in r, s x ∣ z

tactic: refine'
  (IsCoprime.prod_right fun i hir ↦
        Hs aux1 (Finset.mem_insert_of_mem hir) <| by
          rintro rfl
          exact har hir).mul_dvd
    (Hs1 a aux1) (ih (Hs.mono _) fun i hi ↦ Hs1 i <| Finset.mem_insert_of_mem hi)
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
a : I
r : Finset I
har : ¬a ∈ r
ih : Set.Pairwise (↑r) (IsCoprime on s) → (∀ (i : I), i ∈ r → s i ∣ z) → ∏ x in r, s x ∣ z
Hs : Set.Pairwise (↑(insert a r)) (IsCoprime on s)
Hs1 : ∀ (i : I), i ∈ insert a r → s i ∣ z
aux1 : a ∈ ↑(insert a r)
⊢ s a * ∏ x in r, s x ∣ z

tactic: simp only [Finset.coe_insert, Set.subset_insert]
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
a : I
r : Finset I
har : ¬a ∈ r
ih : Set.Pairwise (↑r) (IsCoprime on s) → (∀ (i : I), i ∈ r → s i ∣ z) → ∏ x in r, s x ∣ z
Hs : Set.Pairwise (↑(insert a r)) (IsCoprime on s)
Hs1 : ∀ (i : I), i ∈ insert a r → s i ∣ z
aux1 : a ∈ ↑(insert a r)
⊢ ↑r ⊆ ↑(insert a r)

tactic: rintro rfl
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
a : I
r : Finset I
har : ¬a ∈ r
ih : Set.Pairwise (↑r) (IsCoprime on s) → (∀ (i : I), i ∈ r → s i ∣ z) → ∏ x in r, s x ∣ z
Hs : Set.Pairwise (↑(insert a r)) (IsCoprime on s)
Hs1 : ∀ (i : I), i ∈ insert a r → s i ∣ z
aux1 : a ∈ ↑(insert a r)
i : I
hir : i ∈ r
⊢ a ≠ i

tactic: exact har hir
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
a : I
r : Finset I
har : ¬a ∈ r
ih : Set.Pairwise (↑r) (IsCoprime on s) → (∀ (i : I), i ∈ r → s i ∣ z) → ∏ x in r, s x ∣ z
Hs : Set.Pairwise (↑(insert a r)) (IsCoprime on s)
Hs1 : ∀ (i : I), i ∈ insert a r → s i ∣ z
aux1 : a ∈ ↑(insert a r)
hir : a ∈ r
⊢ False
Theorem: IsUpperSet.div_right
File: Mathlib/Algebra/Order/UpperLower.lean

tactic: rw [div_eq_mul_inv]
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
hs : IsUpperSet s
⊢ IsUpperSet (s / t)

tactic: exact hs.mul_right
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
hs : IsUpperSet s
⊢ IsUpperSet (s * t⁻¹)
Theorem: List.foldr_fixed'
File: Mathlib/Data/List/Basic.lean

tactic: rw [foldr_cons, foldr_fixed' hf l, hf a]
state_before: ι : Type ?u.231002
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β → β
b : β
hf : ∀ (a : α), f a b = b
a : α
l : List α
⊢ foldr f b (a :: l) = b
Theorem: CategoryTheory.MorphismProperty.epimorphisms.iff
File: Mathlib/CategoryTheory/MorphismProperty.lean

tactic: rfl
state_before: C : Type u
inst✝¹ : Category C
D : Type ?u.59557
inst✝ : Category D
X Y : C
f : X ⟶ Y
⊢ epimorphisms C f ↔ Epi f
Theorem: isPiSystem_image_Iio
File: Mathlib/MeasureTheory/PiSystem.lean

tactic: rintro _ ⟨a, ha, rfl⟩ _ ⟨b, hb, rfl⟩ -
state_before: α : Type u_1
ι : Sort ?u.3509
ι' : Sort ?u.3512
inst✝ : LinearOrder α
s : Set α
⊢ IsPiSystem (Iio '' s)

tactic: exact ⟨a ⊓ b, inf_ind a b ha hb, Iio_inter_Iio.symm⟩
state_before: case intro.intro.intro.intro
α : Type u_1
ι : Sort ?u.3509
ι' : Sort ?u.3512
inst✝ : LinearOrder α
s : Set α
a : α
ha : a ∈ s
b : α
hb : b ∈ s
⊢ Iio a ∩ Iio b ∈ Iio '' s
Theorem: LipschitzWith.of_le_add
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

tactic: simpa only [NNReal.coe_one, one_mul]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoMetricSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
K : ℝ≥0
f✝ : α → β
x y : α
r : ℝ
f : α → ℝ
h : ∀ (x y : α), f x ≤ f y + dist x y
⊢ ∀ (x y : α), f x ≤ f y + ↑1 * dist x y
Theorem: GaloisConnection.l_iSup₂
File: Mathlib/Order/GaloisConnection.lean

tactic: simp_rw [gc.l_iSup]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
κ : ι → Sort u_1
a a₁ a₂ : α
b b₁ b₂ : β
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
l : α → β
u : β → α
gc : GaloisConnection l u
f : (i : ι) → κ i → α
⊢ l (⨆ (i : ι) (j : κ i), f i j) = ⨆ (i : ι) (j : κ i), l (f i j)
Theorem: MeasureTheory.SignedMeasure.of_diff_eq_zero_of_symmDiff_eq_zero_negative
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

tactic: rw [← s.neg_le_neg_iff _ hu, neg_zero] at hsu
state_before: α : Type u_1
β : Type ?u.61556
inst✝² : MeasurableSpace α
s : SignedMeasure α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
u v w : Set α
hu : MeasurableSet u
hv : MeasurableSet v
hsu : VectorMeasure.restrict s u ≤ VectorMeasure.restrict 0 u
hsv : VectorMeasure.restrict s v ≤ VectorMeasure.restrict 0 v
hs : ↑s (u ∆ v) = 0
⊢ ↑s (u \ v) = 0 ∧ ↑s (v \ u) = 0

tactic: rw [← s.neg_le_neg_iff _ hv, neg_zero] at hsv
state_before: α : Type u_1
β : Type ?u.61556
inst✝² : MeasurableSpace α
s : SignedMeasure α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
u v w : Set α
hu : MeasurableSet u
hv : MeasurableSet v
hsu : VectorMeasure.restrict 0 u ≤ VectorMeasure.restrict (-s) u
hsv : VectorMeasure.restrict s v ≤ VectorMeasure.restrict 0 v
hs : ↑s (u ∆ v) = 0
⊢ ↑s (u \ v) = 0 ∧ ↑s (v \ u) = 0

tactic: have := of_diff_eq_zero_of_symmDiff_eq_zero_positive hu hv hsu hsv
state_before: α : Type u_1
β : Type ?u.61556
inst✝² : MeasurableSpace α
s : SignedMeasure α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
u v w : Set α
hu : MeasurableSet u
hv : MeasurableSet v
hsu : VectorMeasure.restrict 0 u ≤ VectorMeasure.restrict (-s) u
hsv : VectorMeasure.restrict 0 v ≤ VectorMeasure.restrict (-s) v
hs : ↑s (u ∆ v) = 0
⊢ ↑s (u \ v) = 0 ∧ ↑s (v \ u) = 0

tactic: simp only [Pi.neg_apply, neg_eq_zero, coe_neg] at this
state_before: α : Type u_1
β : Type ?u.61556
inst✝² : MeasurableSpace α
s : SignedMeasure α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
u v w : Set α
hu : MeasurableSet u
hv : MeasurableSet v
hsu : VectorMeasure.restrict 0 u ≤ VectorMeasure.restrict (-s) u
hsv : VectorMeasure.restrict 0 v ≤ VectorMeasure.restrict (-s) v
hs : ↑s (u ∆ v) = 0
this : ↑(-s) (u ∆ v) = 0 → ↑(-s) (u \ v) = 0 ∧ ↑(-s) (v \ u) = 0
⊢ ↑s (u \ v) = 0 ∧ ↑s (v \ u) = 0

tactic: exact this hs
state_before: α : Type u_1
β : Type ?u.61556
inst✝² : MeasurableSpace α
s : SignedMeasure α
μ ν : Measure α
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
u v w : Set α
hu : MeasurableSet u
hv : MeasurableSet v
hsu : VectorMeasure.restrict 0 u ≤ VectorMeasure.restrict (-s) u
hsv : VectorMeasure.restrict 0 v ≤ VectorMeasure.restrict (-s) v
hs : ↑s (u ∆ v) = 0
this : ↑s (u ∆ v) = 0 → ↑s (u \ v) = 0 ∧ ↑s (v \ u) = 0
⊢ ↑s (u \ v) = 0 ∧ ↑s (v \ u) = 0
Theorem: Substring.Valid.get
File: Std/Data/String/Lemmas.lean

tactic: let ⟨l, m, r, h⟩ := h.validFor
state_before: m₁ : List Char
c : Char
m₂ : List Char
x✝ : Substring
h : Valid x✝
e : (toString x✝).data = m₁ ++ c :: m₂
⊢ Substring.get x✝ { byteIdx := utf8Len m₁ } = c

tactic: simp [h.toString] at e
state_before: m₁ : List Char
c : Char
m₂ : List Char
x✝ : Substring
h✝ : Valid x✝
e : (toString x✝).data = m₁ ++ c :: m₂
l m r : List Char
h : ValidFor l m r x✝
⊢ Substring.get x✝ { byteIdx := utf8Len m₁ } = c

tactic: subst e
state_before: m₁ : List Char
c : Char
m₂ : List Char
x✝ : Substring
h✝ : Valid x✝
l m r : List Char
h : ValidFor l m r x✝
e : m = m₁ ++ c :: m₂
⊢ Substring.get x✝ { byteIdx := utf8Len m₁ } = c

tactic: simp [h.get]
state_before: m₁ : List Char
c : Char
m₂ : List Char
x✝ : Substring
h✝ : Valid x✝
l r : List Char
h : ValidFor l (m₁ ++ c :: m₂) r x✝
⊢ Substring.get x✝ { byteIdx := utf8Len m₁ } = c
Theorem: Function.Periodic.map_vadd_zmultiples
File: Mathlib/Algebra/Periodic.lean

tactic: rcases a with ⟨_, m, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.133663
f g : α → β
c c₁ c₂ x✝ : α
inst✝ : AddCommGroup α
hf : Periodic f c
a : { x // x ∈ AddSubgroup.zmultiples c }
x : α
⊢ f (a +ᵥ x) = f x

tactic: simp [AddSubgroup.vadd_def, add_comm _ x, hf.zsmul m x]
state_before: case mk.intro
α : Type u_1
β : Type u_2
γ : Type ?u.133663
f g : α → β
c c₁ c₂ x✝ : α
inst✝ : AddCommGroup α
hf : Periodic f c
x : α
m : ℤ
⊢ f ({ val := (fun x => x • c) m, property := (_ : ∃ y, (fun x => x • c) y = (fun x => x • c) m) } +ᵥ x) = f x
Theorem: LinearIndependent.map'
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: simp [hf_inj]
state_before: ι : Type u'
ι' : Type ?u.105129
R : Type u_1
K : Type ?u.105135
M : Type u_2
M' : Type u_3
M'' : Type ?u.105144
V : Type u
V' : Type ?u.105149
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
hv : LinearIndependent R v
f : M →ₗ[R] M'
hf_inj : LinearMap.ker f = ⊥
⊢ Disjoint (span R (range v)) (LinearMap.ker f)
Theorem: ProbabilityTheory.kernel.integral_const
File: Mathlib/Probability/Kernel/Basic.lean

tactic: rw [kernel.const_apply]
state_before: α : Type u_3
β : Type u_2
ι : Type ?u.1096105
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : { x // x ∈ kernel α β }
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : β → E
μ : MeasureTheory.Measure β
a : α
⊢ (∫ (x : β), f x ∂↑(const α μ) a) = ∫ (x : β), f x ∂μ
Theorem: Cardinal.aleph'_le_of_limit
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rw [← aleph'_alephIdx c, aleph'_le, limit_le l]
state_before: o : Ordinal
l : Ordinal.IsLimit o
c : Cardinal
h : ∀ (o' : Ordinal), o' < o → aleph' o' ≤ c
⊢ aleph' o ≤ c

tactic: intro x h'
state_before: o : Ordinal
l : Ordinal.IsLimit o
c : Cardinal
h : ∀ (o' : Ordinal), o' < o → aleph' o' ≤ c
⊢ ∀ (x : Ordinal), x < o → x ≤ alephIdx c

tactic: rw [← aleph'_le, aleph'_alephIdx]
state_before: o : Ordinal
l : Ordinal.IsLimit o
c : Cardinal
h : ∀ (o' : Ordinal), o' < o → aleph' o' ≤ c
x : Ordinal
h' : x < o
⊢ x ≤ alephIdx c

tactic: exact h _ h'
state_before: o : Ordinal
l : Ordinal.IsLimit o
c : Cardinal
h : ∀ (o' : Ordinal), o' < o → aleph' o' ≤ c
x : Ordinal
h' : x < o
⊢ aleph' x ≤ c
Theorem: Metric.thickening_closure
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: simp_rw [thickening, infEdist_closure]
state_before: ι : Sort ?u.131156
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ ε : ℝ
s t : Set α
x : α
⊢ thickening δ (closure s) = thickening δ s
Theorem: update_lt_self_iff
File: Mathlib/Order/Basic.lean

tactic: simp [lt_iff_le_not_le]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
π : ι → Type u_2
r : α → α → Prop
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Preorder (π i)
x y : (i : ι) → π i
i : ι
a b : π i
⊢ update x i a < x ↔ a < x i
Theorem: Cardinal.isRegular_aleph0
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: simp
state_before: α : Type ?u.145122
r : α → α → Prop
⊢ ℵ₀ ≤ Ordinal.cof (ord ℵ₀)
Theorem: Vector.mem_cons_iff
File: Mathlib/Data/Vector/Mem.lean

tactic: rw [Vector.toList_cons, List.mem_cons]
state_before: α : Type u_1
β : Type ?u.1633
n : ℕ
a a' : α
v : Vector α n
⊢ a' ∈ toList (a ::ᵥ v) ↔ a' = a ∨ a' ∈ toList v