tasksource/leandojo huggingface dataset:
Theorem: DenseRange.prod_map
File: Mathlib/Topology/Constructions.lean

tactic: simpa only [DenseRange, prod_range_range_eq] using hf.prod hg
state_before: α : Type u
β : Type v
γ : Type u_3
δ : Type ?u.64152
ε : Type ?u.64155
ζ : Type ?u.64158
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
ι : Type u_1
κ : Type u_2
f : ι → β
g : κ → γ
hf : DenseRange f
hg : DenseRange g
⊢ DenseRange (Prod.map f g)
Theorem: MeasureTheory.Measure.measurePreserving_div_left
File: Mathlib/MeasureTheory/Group/Measure.lean

tactic: simp_rw [div_eq_mul_inv]
state_before: 𝕜 : Type ?u.510422
G : Type u_1
H : Type ?u.510428
inst✝⁶ : MeasurableSpace G
inst✝⁵ : MeasurableSpace H
inst✝⁴ : DivisionMonoid G
inst✝³ : MeasurableMul G
inst✝² : MeasurableInv G
μ✝ μ : Measure G
inst✝¹ : IsInvInvariant μ
inst✝ : IsMulLeftInvariant μ
g : G
⊢ MeasurePreserving fun t => g / t

tactic: exact (measurePreserving_mul_left μ g).comp (measurePreserving_inv μ)
state_before: 𝕜 : Type ?u.510422
G : Type u_1
H : Type ?u.510428
inst✝⁶ : MeasurableSpace G
inst✝⁵ : MeasurableSpace H
inst✝⁴ : DivisionMonoid G
inst✝³ : MeasurableMul G
inst✝² : MeasurableInv G
μ✝ μ : Measure G
inst✝¹ : IsInvInvariant μ
inst✝ : IsMulLeftInvariant μ
g : G
⊢ MeasurePreserving fun t => g * t⁻¹
Theorem: List.concat_eq_append
File: src/lean/Init/Data/List/Basic.lean

tactic: induction as <;> simp [concat, *]
state_before: α : Type u
β : Type v
γ : Type w
as : List α
a : α
⊢ concat as a = as ++ a :: nil
Theorem: QuotientAddGroup.norm_mk
File: Mathlib/Analysis/Normed/Group/Quotient.lean

tactic: rw [norm_eq_infDist, ← infDist_image (IsometryEquiv.subLeft x).isometry,
  IsometryEquiv.subLeft_apply, sub_zero, ← IsometryEquiv.preimage_symm]
state_before: M : Type u_1
N : Type ?u.27150
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x : M
⊢ ‖↑x‖ = infDist x ↑S

tactic: congr 1 with y
state_before: M : Type u_1
N : Type ?u.27150
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x : M
⊢ infDist x (↑(IsometryEquiv.symm (IsometryEquiv.subLeft x)) ⁻¹' {m | ↑m = ↑x}) = infDist x ↑S

tactic: simp only [mem_preimage, IsometryEquiv.subLeft_symm_apply, mem_setOf_eq, QuotientAddGroup.eq,
  neg_add, neg_neg, neg_add_cancel_right, SetLike.mem_coe]
state_before: case e_s.h
M : Type u_1
N : Type ?u.27150
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x y : M
⊢ y ∈ ↑(IsometryEquiv.symm (IsometryEquiv.subLeft x)) ⁻¹' {m | ↑m = ↑x} ↔ y ∈ ↑S
Theorem: MeasureTheory.OuterMeasure.map_ofFunction_le
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: rw [map_apply]
state_before: α : Type u_2
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
β : Type u_1
f : α → β
s : Set β
⊢ ↑(↑(map f) (OuterMeasure.ofFunction m m_empty)) s ≤ m (f ⁻¹' s)

tactic: apply ofFunction_le
state_before: α : Type u_2
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
β : Type u_1
f : α → β
s : Set β
⊢ ↑(OuterMeasure.ofFunction m m_empty) (f ⁻¹' s) ≤ m (f ⁻¹' s)
Theorem: isRightRegular_of_mul_eq_one
File: Mathlib/Algebra/Regular/Basic.lean

tactic: rw [h]
state_before: R : Type u_1
inst✝ : Monoid R
a b : R
h : a * b = 1
⊢ IsRightRegular (a * ?m.14188 h)

tactic: exact isRegular_one.right
state_before: R : Type u_1
inst✝ : Monoid R
a b : R
h : a * b = 1
⊢ IsRightRegular 1
Theorem: FirstOrder.Language.LHom.id_comp
File: Mathlib/ModelTheory/LanguageMap.lean

tactic: cases F
state_before: L : Language
L' : Language
M : Type w
inst✝ : Structure L M
ϕ : L →ᴸ L'
L'' : Language
F : L →ᴸ L'
⊢ LHom.id L' ∘' F = F

tactic: rfl
state_before: case mk
L : Language
L' : Language
M : Type w
inst✝ : Structure L M
ϕ : L →ᴸ L'
L'' : Language
onFunction✝ : ⦃n : ℕ⦄ → Functions L n → Functions L' n
onRelation✝ : ⦃n : ℕ⦄ → Relations L n → Relations L' n
⊢ LHom.id L' ∘' { onFunction := onFunction✝, onRelation := onRelation✝ } =
    { onFunction := onFunction✝, onRelation := onRelation✝ }
Theorem: VitaliFamily.mem_filterAt_iff
File: Mathlib/MeasureTheory/Covering/VitaliFamily.lean

tactic: simp only [filterAt, exists_prop, gt_iff_lt]
state_before: α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v : VitaliFamily μ
x : α
s : Set (Set α)
⊢ s ∈ filterAt v x ↔ ∃ ε, ε > 0 ∧ ∀ (a : Set α), a ∈ setsAt v x → a ⊆ closedBall x ε → a ∈ s

tactic: rw [mem_biInf_of_directed]
state_before: α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v : VitaliFamily μ
x : α
s : Set (Set α)
⊢ (s ∈ ⨅ (ε : ℝ) (_ : ε ∈ Ioi 0), 𝓟 {a | a ∈ setsAt v x ∧ a ⊆ closedBall x ε}) ↔
    ∃ ε, 0 < ε ∧ ∀ (a : Set α), a ∈ setsAt v x → a ⊆ closedBall x ε → a ∈ s

tactic: simp only [subset_def, and_imp, exists_prop, mem_sep_iff, mem_Ioi, mem_principal]
state_before: α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v : VitaliFamily μ
x : α
s : Set (Set α)
⊢ (∃ i, i ∈ Ioi 0 ∧ s ∈ 𝓟 {a | a ∈ setsAt v x ∧ a ⊆ closedBall x i}) ↔
    ∃ ε, 0 < ε ∧ ∀ (a : Set α), a ∈ setsAt v x → a ⊆ closedBall x ε → a ∈ s

tactic: simp only [DirectedOn, exists_prop, ge_iff_le, le_principal_iff, mem_Ioi, Order.Preimage,
  mem_principal]
state_before: case h
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v : VitaliFamily μ
x : α
s : Set (Set α)
⊢ DirectedOn ((fun ε => 𝓟 {a | a ∈ setsAt v x ∧ a ⊆ closedBall x ε}) ⁻¹'o fun x x_1 => x ≥ x_1) (Ioi 0)

tactic: intro x hx y hy
state_before: case h
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v : VitaliFamily μ
x : α
s : Set (Set α)
⊢ ∀ (x_1 : ℝ),
    0 < x_1 →
      ∀ (y : ℝ),
        0 < y →
          ∃ z,
            0 < z ∧
              {a | a ∈ setsAt v x ∧ a ⊆ closedBall x z} ⊆ {a | a ∈ setsAt v x ∧ a ⊆ closedBall x x_1} ∧
                {a | a ∈ setsAt v x ∧ a ⊆ closedBall x z} ⊆ {a | a ∈ setsAt v x ∧ a ⊆ closedBall x y}

tactic: refine' ⟨min x y, lt_min hx hy,
  fun a ha => ⟨ha.1, ha.2.trans (closedBall_subset_closedBall (min_le_left _ _))⟩,
  fun a ha => ⟨ha.1, ha.2.trans (closedBall_subset_closedBall (min_le_right _ _))⟩⟩
state_before: case h
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v : VitaliFamily μ
x✝ : α
s : Set (Set α)
x : ℝ
hx : 0 < x
y : ℝ
hy : 0 < y
⊢ ∃ z,
    0 < z ∧
      {a | a ∈ setsAt v x✝ ∧ a ⊆ closedBall x✝ z} ⊆ {a | a ∈ setsAt v x✝ ∧ a ⊆ closedBall x✝ x} ∧
        {a | a ∈ setsAt v x✝ ∧ a ⊆ closedBall x✝ z} ⊆ {a | a ∈ setsAt v x✝ ∧ a ⊆ closedBall x✝ y}

tactic: exact ⟨(1 : ℝ), mem_Ioi.2 zero_lt_one⟩
state_before: case ne
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v : VitaliFamily μ
x : α
s : Set (Set α)
⊢ Set.Nonempty (Ioi 0)
Theorem: Fin.succ_pos
File: Mathlib/Data/Fin/Basic.lean

tactic: simp [lt_iff_val_lt_val]
state_before: n m : ℕ
a : Fin n
⊢ 0 < succ a
Theorem: MonoidHom.comp_inv
File: Mathlib/Algebra/Hom/Group.lean

tactic: ext
state_before: α : Type ?u.241739
β : Type ?u.241742
M✝ : Type ?u.241745
N : Type ?u.241748
P : Type ?u.241751
G : Type ?u.241754
H : Type ?u.241757
F : Type ?u.241760
inst✝⁵ : Group G
inst✝⁴ : CommGroup H
inst✝³ : MulOneClass M✝
M : Type u_1
A : Type u_2
B : Type u_3
inst✝² : MulOneClass M
inst✝¹ : CommGroup A
inst✝ : CommGroup B
φ : A →* B
ψ : M →* A
⊢ comp φ ψ⁻¹ = (comp φ ψ)⁻¹

tactic: simp only [Function.comp_apply, inv_apply, map_inv, coe_comp]
state_before: case h
α : Type ?u.241739
β : Type ?u.241742
M✝ : Type ?u.241745
N : Type ?u.241748
P : Type ?u.241751
G : Type ?u.241754
H : Type ?u.241757
F : Type ?u.241760
inst✝⁵ : Group G
inst✝⁴ : CommGroup H
inst✝³ : MulOneClass M✝
M : Type u_1
A : Type u_2
B : Type u_3
inst✝² : MulOneClass M
inst✝¹ : CommGroup A
inst✝ : CommGroup B
φ : A →* B
ψ : M →* A
x✝ : M
⊢ ↑(comp φ ψ⁻¹) x✝ = ↑(comp φ ψ)⁻¹ x✝
Theorem: intervalIntegral.integral_eq_sub_of_hasDeriv_right
File: Mathlib/MeasureTheory/Integral/FundThmCalculus.lean

tactic: cases' le_total a b with hab hab
state_before: ι : Type ?u.1842380
𝕜 : Type ?u.1842383
E : Type u_1
F : Type ?u.1842389
A : Type ?u.1842392
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f✝ : ℝ → E
g' g φ : ℝ → ℝ
f f' : ℝ → E
a b : ℝ
hcont : ContinuousOn f [[a, b]]
hderiv : ∀ (x : ℝ), x ∈ Ioo (min a b) (max a b) → HasDerivWithinAt f (f' x) (Ioi x) x
hint : IntervalIntegrable f' volume a b
⊢ (∫ (y : ℝ) in a..b, f' y) = f b - f a

tactic: simp only [uIcc_of_le, min_eq_left, max_eq_right, hab] at hcont hderiv hint
state_before: case inl
ι : Type ?u.1842380
𝕜 : Type ?u.1842383
E : Type u_1
F : Type ?u.1842389
A : Type ?u.1842392
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f✝ : ℝ → E
g' g φ : ℝ → ℝ
f f' : ℝ → E
a b : ℝ
hcont : ContinuousOn f [[a, b]]
hderiv : ∀ (x : ℝ), x ∈ Ioo (min a b) (max a b) → HasDerivWithinAt f (f' x) (Ioi x) x
hint : IntervalIntegrable f' volume a b
hab : a ≤ b
⊢ (∫ (y : ℝ) in a..b, f' y) = f b - f a

tactic: apply integral_eq_sub_of_hasDeriv_right_of_le hab hcont hderiv hint
state_before: case inl
ι : Type ?u.1842380
𝕜 : Type ?u.1842383
E : Type u_1
F : Type ?u.1842389
A : Type ?u.1842392
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f✝ : ℝ → E
g' g φ : ℝ → ℝ
f f' : ℝ → E
a b : ℝ
hint : IntervalIntegrable f' volume a b
hab : a ≤ b
hcont : ContinuousOn f (Icc a b)
hderiv : ∀ (x : ℝ), x ∈ Ioo a b → HasDerivWithinAt f (f' x) (Ioi x) x
⊢ (∫ (y : ℝ) in a..b, f' y) = f b - f a

tactic: simp only [uIcc_of_ge, min_eq_right, max_eq_left, hab] at hcont hderiv
state_before: case inr
ι : Type ?u.1842380
𝕜 : Type ?u.1842383
E : Type u_1
F : Type ?u.1842389
A : Type ?u.1842392
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f✝ : ℝ → E
g' g φ : ℝ → ℝ
f f' : ℝ → E
a b : ℝ
hcont : ContinuousOn f [[a, b]]
hderiv : ∀ (x : ℝ), x ∈ Ioo (min a b) (max a b) → HasDerivWithinAt f (f' x) (Ioi x) x
hint : IntervalIntegrable f' volume a b
hab : b ≤ a
⊢ (∫ (y : ℝ) in a..b, f' y) = f b - f a

tactic: rw [integral_symm, integral_eq_sub_of_hasDeriv_right_of_le hab hcont hderiv hint.symm, neg_sub]
state_before: case inr
ι : Type ?u.1842380
𝕜 : Type ?u.1842383
E : Type u_1
F : Type ?u.1842389
A : Type ?u.1842392
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f✝ : ℝ → E
g' g φ : ℝ → ℝ
f f' : ℝ → E
a b : ℝ
hint : IntervalIntegrable f' volume a b
hab : b ≤ a
hcont : ContinuousOn f (Icc b a)
hderiv : ∀ (x : ℝ), x ∈ Ioo b a → HasDerivWithinAt f (f' x) (Ioi x) x
⊢ (∫ (y : ℝ) in a..b, f' y) = f b - f a
Theorem: Behrend.map_zero
File: Mathlib/Combinatorics/Additive/Behrend.lean

tactic: simp [map]
state_before: α : Type ?u.37158
β : Type ?u.37161
n d✝ k N : ℕ
x : Fin n → ℕ
d : ℕ
a : Fin 0 → ℕ
⊢ ↑(map d) a = 0
Theorem: CategoryTheory.kernelSubobject_arrow_eq_zero_of_exact_zero_left
File: Mathlib/Algebra/Homology/Exact.lean

tactic: haveI := h.epi
state_before: V : Type u
inst✝³ : Category V
inst✝² : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h✝ : C ⟶ D
inst✝¹ : HasZeroMorphisms V
inst✝ : HasEqualizers V
h : Exact 0 g
⊢ Subobject.arrow (kernelSubobject g) = 0

tactic: rw [← cancel_epi (imageToKernel (0 : A ⟶ B) g h.w), ←
  cancel_epi (factorThruImageSubobject (0 : A ⟶ B))]
state_before: V : Type u
inst✝³ : Category V
inst✝² : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h✝ : C ⟶ D
inst✝¹ : HasZeroMorphisms V
inst✝ : HasEqualizers V
h : Exact 0 g
this : Epi (imageToKernel 0 g (_ : 0 ≫ g = 0))
⊢ Subobject.arrow (kernelSubobject g) = 0

tactic: simp
state_before: V : Type u
inst✝³ : Category V
inst✝² : HasImages V
A B C D : V
f : A ⟶ B
g : B ⟶ C
h✝ : C ⟶ D
inst✝¹ : HasZeroMorphisms V
inst✝ : HasEqualizers V
h : Exact 0 g
this : Epi (imageToKernel 0 g (_ : 0 ≫ g = 0))
⊢ factorThruImageSubobject 0 ≫ imageToKernel 0 g (_ : 0 ≫ g = 0) ≫ Subobject.arrow (kernelSubobject g) =
    factorThruImageSubobject 0 ≫ imageToKernel 0 g (_ : 0 ≫ g = 0) ≫ 0
Theorem: Finsupp.prod_mapRange_index
File: Mathlib/Algebra/BigOperators/Finsupp.lean

tactic: rw [not_mem_support_iff.1 H, h0]
state_before: α : Type u_3
ι : Type ?u.32313
γ : Type ?u.32316
A : Type ?u.32319
B : Type ?u.32322
C : Type ?u.32325
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : AddCommMonoid C
t : ι → A → C
h0✝ : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s : Finset α
f✝ : α → ι →₀ A
i : ι
g✝ : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type ?u.35455
M : Type u_2
M' : Type u_1
N : Type u_4
P : Type ?u.35467
G : Type ?u.35470
H✝ : Type ?u.35473
R : Type ?u.35476
S : Type ?u.35479
inst✝² : Zero M
inst✝¹ : Zero M'
inst✝ : CommMonoid N
f : M → M'
hf : f 0 = 0
g : α →₀ M
h : α → M' → N
h0 : ∀ (a : α), h a 0 = 1
x✝¹ : α
x✝ : x✝¹ ∈ g.support
H : ¬x✝¹ ∈ (mapRange f hf g).support
⊢ h x✝¹ (↑(mapRange f hf g) x✝¹) = 1
Theorem: smul_algebraMap
File: Mathlib/Algebra/Algebra/Basic.lean

tactic: rw [algebraMap_eq_smul_one, smul_comm a r (1 : A), smul_one]
state_before: R : Type u
S : Type v
A : Type w
B : Type ?u.321762
inst✝⁸ : CommSemiring R
inst✝⁷ : CommSemiring S
inst✝⁶ : Semiring A
inst✝⁵ : Algebra R A
inst✝⁴ : Semiring B
inst✝³ : Algebra R B
α : Type u_1
inst✝² : Monoid α
inst✝¹ : MulDistribMulAction α A
inst✝ : SMulCommClass α R A
a : α
r : R
⊢ a • ↑(algebraMap R A) r = ↑(algebraMap R A) r
Theorem: Matrix.StdBasisMatrix.apply_of_ne
File: Mathlib/Data/Matrix/Basis.lean

tactic: simp only [stdBasisMatrix, and_imp, ite_eq_right_iff]
state_before: l : Type ?u.21103
m : Type u_1
n : Type u_2
R : Type ?u.21112
α : Type u_3
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : DecidableEq n
inst✝ : Semiring α
i : m
j : n
c : α
i' : m
j' : n
h : ¬(i = i' ∧ j = j')
⊢ stdBasisMatrix i j c i' j' = 0

tactic: tauto
state_before: l : Type ?u.21103
m : Type u_1
n : Type u_2
R : Type ?u.21112
α : Type u_3
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : DecidableEq n
inst✝ : Semiring α
i : m
j : n
c : α
i' : m
j' : n
h : ¬(i = i' ∧ j = j')
⊢ i = i' → j = j' → c = 0
Theorem: Equiv.Perm.isConj_swap
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: rw [mul_inv_rev, swap_inv, swap_inv, mul_assoc (swap w y), mul_assoc (swap w y), ←
  mul_assoc _ (swap x z), swap_mul_swap_mul_swap hwx hwz, ← mul_assoc,
  swap_mul_swap_mul_swap hwz.symm hyz.symm]
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
w x y✝ z✝ : α
hwx : w ≠ x
hyz✝ : y✝ ≠ z✝
y z : α
hyz : y ≠ z
hwz : w ≠ z
⊢ swap w y * swap x z * swap w x * (swap w y * swap x z)⁻¹ = swap y z

tactic: rw [hwz]
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
w x y z : α
hwx : w ≠ x
hyz : y ≠ z
h : ∀ {y z : α}, y ≠ z → w ≠ z → swap w y * swap x z * swap w x * (swap w y * swap x z)⁻¹ = swap y z
hwz : w = z
⊢ w ≠ y

tactic: exact hyz.symm
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
w x y z : α
hwx : w ≠ x
hyz : y ≠ z
h : ∀ {y z : α}, y ≠ z → w ≠ z → swap w y * swap x z * swap w x * (swap w y * swap x z)⁻¹ = swap y z
hwz : w = z
⊢ z ≠ y

tactic: rw [swap_comm y z, h hyz.symm hwy]
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
w x y z : α
hwx : w ≠ x
hyz : y ≠ z
h : ∀ {y z : α}, y ≠ z → w ≠ z → swap w y * swap x z * swap w x * (swap w y * swap x z)⁻¹ = swap y z
hwz : w = z
hwy : w ≠ y
⊢ swap w z * swap x y * swap w x * (swap w z * swap x y)⁻¹ = swap y z
Theorem: FreeAddMonoid.countp_of
File: Mathlib/Algebra/FreeMonoid/Count.lean

tactic: simp [countp, List.countp, List.countp.go]
state_before: α : Type u_1
p : α → Prop
inst✝ : DecidablePred p
x : α
⊢ ↑(countp p) (of x) = if p x = (true = true) then 1 else 0
Theorem: exists_seq_of_forall_finset_exists'
File: Mathlib/Data/Fintype/Basic.lean

tactic: rcases exists_seq_of_forall_finset_exists P r h with ⟨f, hf, hf'⟩
state_before: α✝ : Type ?u.168313
β : Type ?u.168316
γ : Type ?u.168319
α : Type u_1
P : α → Prop
r : α → α → Prop
inst✝ : IsSymm α r
h : ∀ (s : Finset α), (∀ (x : α), x ∈ s → P x) → ∃ y, P y ∧ ∀ (x : α), x ∈ s → r x y
⊢ ∃ f, (∀ (n : ℕ), P (f n)) ∧ ∀ (m n : ℕ), m ≠ n → r (f m) (f n)

tactic: refine' ⟨f, hf, fun m n hmn => _⟩
state_before: case intro.intro
α✝ : Type ?u.168313
β : Type ?u.168316
γ : Type ?u.168319
α : Type u_1
P : α → Prop
r : α → α → Prop
inst✝ : IsSymm α r
h : ∀ (s : Finset α), (∀ (x : α), x ∈ s → P x) → ∃ y, P y ∧ ∀ (x : α), x ∈ s → r x y
f : ℕ → α
hf : ∀ (n : ℕ), P (f n)
hf' : ∀ (m n : ℕ), m < n → r (f m) (f n)
⊢ ∃ f, (∀ (n : ℕ), P (f n)) ∧ ∀ (m n : ℕ), m ≠ n → r (f m) (f n)

tactic: rcases lt_trichotomy m n with (h | rfl | h)
state_before: case intro.intro
α✝ : Type ?u.168313
β : Type ?u.168316
γ : Type ?u.168319
α : Type u_1
P : α → Prop
r : α → α → Prop
inst✝ : IsSymm α r
h : ∀ (s : Finset α), (∀ (x : α), x ∈ s → P x) → ∃ y, P y ∧ ∀ (x : α), x ∈ s → r x y
f : ℕ → α
hf : ∀ (n : ℕ), P (f n)
hf' : ∀ (m n : ℕ), m < n → r (f m) (f n)
m n : ℕ
hmn : m ≠ n
⊢ r (f m) (f n)

tactic: exact hf' m n h
state_before: case intro.intro.inl
α✝ : Type ?u.168313
β : Type ?u.168316
γ : Type ?u.168319
α : Type u_1
P : α → Prop
r : α → α → Prop
inst✝ : IsSymm α r
h✝ : ∀ (s : Finset α), (∀ (x : α), x ∈ s → P x) → ∃ y, P y ∧ ∀ (x : α), x ∈ s → r x y
f : ℕ → α
hf : ∀ (n : ℕ), P (f n)
hf' : ∀ (m n : ℕ), m < n → r (f m) (f n)
m n : ℕ
hmn : m ≠ n
h : m < n
⊢ r (f m) (f n)

tactic: exact (hmn rfl).elim
state_before: case intro.intro.inr.inl
α✝ : Type ?u.168313
β : Type ?u.168316
γ : Type ?u.168319
α : Type u_1
P : α → Prop
r : α → α → Prop
inst✝ : IsSymm α r
h : ∀ (s : Finset α), (∀ (x : α), x ∈ s → P x) → ∃ y, P y ∧ ∀ (x : α), x ∈ s → r x y
f : ℕ → α
hf : ∀ (n : ℕ), P (f n)
hf' : ∀ (m n : ℕ), m < n → r (f m) (f n)
m : ℕ
hmn : m ≠ m
⊢ r (f m) (f m)

tactic: apply symm
state_before: case intro.intro.inr.inr
α✝ : Type ?u.168313
β : Type ?u.168316
γ : Type ?u.168319
α : Type u_1
P : α → Prop
r : α → α → Prop
inst✝ : IsSymm α r
h✝ : ∀ (s : Finset α), (∀ (x : α), x ∈ s → P x) → ∃ y, P y ∧ ∀ (x : α), x ∈ s → r x y
f : ℕ → α
hf : ∀ (n : ℕ), P (f n)
hf' : ∀ (m n : ℕ), m < n → r (f m) (f n)
m n : ℕ
hmn : m ≠ n
h : n < m
⊢ r (f m) (f n)

tactic: exact hf' n m h
state_before: case intro.intro.inr.inr.a
α✝ : Type ?u.168313
β : Type ?u.168316
γ : Type ?u.168319
α : Type u_1
P : α → Prop
r : α → α → Prop
inst✝ : IsSymm α r
h✝ : ∀ (s : Finset α), (∀ (x : α), x ∈ s → P x) → ∃ y, P y ∧ ∀ (x : α), x ∈ s → r x y
f : ℕ → α
hf : ∀ (n : ℕ), P (f n)
hf' : ∀ (m n : ℕ), m < n → r (f m) (f n)
m n : ℕ
hmn : m ≠ n
h : n < m
⊢ r (f n) (f m)
Theorem: topologicalGroup_is_uniform_of_compactSpace
File: Mathlib/Topology/Algebra/UniformGroup.lean

tactic: apply CompactSpace.uniformContinuous_of_continuous
state_before: G : Type u_1
inst✝³ : Group G
inst✝² : TopologicalSpace G
inst✝¹ : TopologicalGroup G
inst✝ : CompactSpace G
⊢ UniformContinuous fun p => p.fst / p.snd

tactic: exact continuous_div'
state_before: case h
G : Type u_1
inst✝³ : Group G
inst✝² : TopologicalSpace G
inst✝¹ : TopologicalGroup G
inst✝ : CompactSpace G
⊢ Continuous fun p => p.fst / p.snd
Theorem: Real.Angle.two_zsmul_eq_pi_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [two_zsmul, ← two_nsmul, two_nsmul_eq_pi_iff]
state_before: θ : Angle
⊢ 2 • θ = ↑π ↔ θ = ↑(π / 2) ∨ θ = ↑(-π / 2)
Theorem: Multiset.erase_add_right_pos
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [add_comm, erase_add_left_pos s h, add_comm]
state_before: α : Type u_1
β : Type ?u.97707
γ : Type ?u.97710
inst✝ : DecidableEq α
s✝ t✝ : Multiset α
a✝ b a : α
s t : Multiset α
h : a ∈ t
⊢ erase (s + t) a = s + erase t a
Theorem: Pell.xn_one
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: simp
state_before: a : ℕ
a1 : 1 < a
⊢ xn a1 1 = a
Theorem: CategoryTheory.isCodetector_unop_iff
File: Mathlib/CategoryTheory/Generator.lean

tactic: rw [IsDetector, IsCodetector, ← isCodetecting_unop_iff, Set.singleton_unop]
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
G : Cᵒᵖ
⊢ IsCodetector G.unop ↔ IsDetector G
Theorem: List.length_le_sum_of_one_le
File: Mathlib/Data/List/BigOperators/Lemmas.lean

tactic: induction' L with j L IH h
state_before: ι : Type ?u.8615
α : Type ?u.8618
M : Type ?u.8621
N : Type ?u.8624
P : Type ?u.8627
M₀ : Type ?u.8630
G : Type ?u.8633
R : Type ?u.8636
L : List ℕ
h : ∀ (i : ℕ), i ∈ L → 1 ≤ i
⊢ length L ≤ sum L

tactic: rw [sum_cons, length, add_comm]
state_before: case cons
ι : Type ?u.8615
α : Type ?u.8618
M : Type ?u.8621
N : Type ?u.8624
P : Type ?u.8627
M₀ : Type ?u.8630
G : Type ?u.8633
R : Type ?u.8636
L✝ : List ℕ
h✝ : ∀ (i : ℕ), i ∈ L✝ → 1 ≤ i
j : ℕ
L : List ℕ
IH : (∀ (i : ℕ), i ∈ L → 1 ≤ i) → length L ≤ sum L
h : ∀ (i : ℕ), i ∈ j :: L → 1 ≤ i
⊢ length (j :: L) ≤ sum (j :: L)

tactic: exact add_le_add (h _ (mem_cons_self _ _)) (IH fun i hi => h i (mem_cons.2 (Or.inr hi)))
state_before: case cons
ι : Type ?u.8615
α : Type ?u.8618
M : Type ?u.8621
N : Type ?u.8624
P : Type ?u.8627
M₀ : Type ?u.8630
G : Type ?u.8633
R : Type ?u.8636
L✝ : List ℕ
h✝ : ∀ (i : ℕ), i ∈ L✝ → 1 ≤ i
j : ℕ
L : List ℕ
IH : (∀ (i : ℕ), i ∈ L → 1 ≤ i) → length L ≤ sum L
h : ∀ (i : ℕ), i ∈ j :: L → 1 ≤ i
⊢ 1 + length L ≤ j + sum L

tactic: simp
state_before: case nil
ι : Type ?u.8615
α : Type ?u.8618
M : Type ?u.8621
N : Type ?u.8624
P : Type ?u.8627
M₀ : Type ?u.8630
G : Type ?u.8633
R : Type ?u.8636
L : List ℕ
h✝ : ∀ (i : ℕ), i ∈ L → 1 ≤ i
h : ∀ (i : ℕ), i ∈ [] → 1 ≤ i
⊢ length [] ≤ sum []
Theorem: FractionalIdeal.coe_mul
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: simp only [mul_def]
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I J : FractionalIdeal S P
⊢ ↑(I * J) = ↑I * ↑J

tactic: rfl
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I J : FractionalIdeal S P
⊢ ↑{ val := ↑I * ↑J, property := (_ : IsFractional S (↑I * ↑J)) } = ↑I * ↑J
Theorem: measurableSet_graph
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: simpa using measurableSet_region_between_cc hf hf MeasurableSet.univ
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
f g : α → ℝ
s : Set α
hf : Measurable f
⊢ MeasurableSet {p | p.snd = f p.fst}
Theorem: MeasureTheory.Measure.restrict_sInf_eq_sInf_restrict
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: ext1 s hs
state_before: α : Type u_1
β : Type ?u.317389
γ : Type ?u.317392
δ : Type ?u.317395
ι : Type ?u.317398
R : Type ?u.317401
R' : Type ?u.317404
m0✝ : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
m0 : MeasurableSpace α
m : Set (Measure α)
hm : Set.Nonempty m
ht : MeasurableSet t
⊢ restrict (sInf m) t = sInf ((fun μ => restrict μ t) '' m)

tactic: simp_rw [sInf_apply hs, restrict_apply hs, sInf_apply (MeasurableSet.inter hs ht),
  Set.image_image, restrict_toOuterMeasure_eq_toOuterMeasure_restrict ht, ←
  Set.image_image _ toOuterMeasure, ← OuterMeasure.restrict_sInf_eq_sInf_restrict _ (hm.image _),
  OuterMeasure.restrict_apply]
state_before: case h
α : Type u_1
β : Type ?u.317389
γ : Type ?u.317392
δ : Type ?u.317395
ι : Type ?u.317398
R : Type ?u.317401
R' : Type ?u.317404
m0✝ : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
m0 : MeasurableSpace α
m : Set (Measure α)
hm : Set.Nonempty m
ht : MeasurableSet t
s : Set α
hs : MeasurableSet s
⊢ ↑↑(restrict (sInf m) t) s = ↑↑(sInf ((fun μ => restrict μ t) '' m)) s