tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.Presieve.pullback_singleton
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: funext W
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
inst✝ : HasPullbacks C
g : Z ⟶ X
⊢ pullbackArrows f (singleton g) = singleton pullback.snd

tactic: ext h
state_before: case h
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
inst✝ : HasPullbacks C
g : Z ⟶ X
W : C
⊢ pullbackArrows f (singleton g) = singleton pullback.snd

tactic: constructor
state_before: case h.h
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
inst✝ : HasPullbacks C
g : Z ⟶ X
W : C
h : W ⟶ Y
⊢ h ∈ pullbackArrows f (singleton g) ↔ h ∈ singleton pullback.snd

tactic: rintro ⟨W, _, _, _⟩
state_before: case h.h.mp
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
inst✝ : HasPullbacks C
g : Z ⟶ X
W : C
h : W ⟶ Y
⊢ h ∈ pullbackArrows f (singleton g) → h ∈ singleton pullback.snd

tactic: exact singleton.mk
state_before: case h.h.mp.mk.mk
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y✝¹ Z : C
f : Y✝¹ ⟶ X
inst✝ : HasPullbacks C
g : Z ⟶ X
Y✝ Y : C
⊢ pullback.snd ∈ singleton pullback.snd

tactic: rintro ⟨_⟩
state_before: case h.h.mpr
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
inst✝ : HasPullbacks C
g : Z ⟶ X
W : C
h : W ⟶ Y
⊢ h ∈ singleton pullback.snd → h ∈ pullbackArrows f (singleton g)

tactic: exact pullbackArrows.mk Z g singleton.mk
state_before: case h.h.mpr.mk
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y✝ Z : C
f : Y✝ ⟶ X
inst✝ : HasPullbacks C
g : Z ⟶ X
Y : C
⊢ pullback.snd ∈ pullbackArrows f (singleton g)
Theorem: Int.ne_of_odd_add
File: Mathlib/Data/Int/Parity.lean

tactic: simp [hnot, parity_simps] at h
state_before: m n : ℤ
h : Odd (m + n)
hnot : m = n
⊢ False
Theorem: TypeVec.nilFun_comp
File: Mathlib/Data/TypeVec.lean

tactic: apply Fin2.elim0 x
state_before: n : ℕ
α₀ : TypeVec 0
f₀ : α₀ ⟹ Fin2.elim0
x : Fin2 0
⊢ (nilFun ⊚ f₀) x = f₀ x
Theorem: MeasureTheory.measure_symmDiff_eq_zero_iff
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: simp [ae_eq_set, symmDiff_def]
state_before: α : Type u_1
β : Type ?u.108610
γ : Type ?u.108613
δ : Type ?u.108616
ι : Type ?u.108619
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ s t : Set α
⊢ ↑↑μ (s ∆ t) = 0 ↔ s =ᵐ[μ] t
Theorem: Finset.powerset_card_disjiUnion
File: Mathlib/Data/Finset/Powerset.lean

tactic: refine' ext fun a => ⟨fun ha => _, fun ha => _⟩
state_before: α : Type u_1
s✝ t s : Finset α
⊢ powerset s =
    disjiUnion (range (card s + 1)) (fun i => powersetLen i s)
      (_ : Set.Pairwise ↑(range (card s + 1)) fun i j => _root_.Disjoint (powersetLen i s) (powersetLen j s))

tactic: rw [mem_disjiUnion]
state_before: case refine'_1
α : Type u_1
s✝ t s a : Finset α
ha : a ∈ powerset s
⊢ a ∈
    disjiUnion (range (card s + 1)) (fun i => powersetLen i s)
      (_ : Set.Pairwise ↑(range (card s + 1)) fun i j => _root_.Disjoint (powersetLen i s) (powersetLen j s))

tactic: exact
  ⟨a.card, mem_range.mpr (Nat.lt_succ_of_le (card_le_of_subset (mem_powerset.mp ha))),
    mem_powersetLen.mpr ⟨mem_powerset.mp ha, rfl⟩⟩
state_before: case refine'_1
α : Type u_1
s✝ t s a : Finset α
ha : a ∈ powerset s
⊢ ∃ a_1, a_1 ∈ range (card s + 1) ∧ a ∈ powersetLen a_1 s

tactic: rcases mem_disjiUnion.mp ha with ⟨i, _hi, ha⟩
state_before: case refine'_2
α : Type u_1
s✝ t s a : Finset α
ha :
  a ∈
    disjiUnion (range (card s + 1)) (fun i => powersetLen i s)
      (_ : Set.Pairwise ↑(range (card s + 1)) fun i j => _root_.Disjoint (powersetLen i s) (powersetLen j s))
⊢ a ∈ powerset s

tactic: exact mem_powerset.mpr (mem_powersetLen.mp ha).1
state_before: case refine'_2.intro.intro
α : Type u_1
s✝ t s a : Finset α
ha✝ :
  a ∈
    disjiUnion (range (card s + 1)) (fun i => powersetLen i s)
      (_ : Set.Pairwise ↑(range (card s + 1)) fun i j => _root_.Disjoint (powersetLen i s) (powersetLen j s))
i : ℕ
_hi : i ∈ range (card s + 1)
ha : a ∈ powersetLen i s
⊢ a ∈ powerset s
Theorem: Bornology.isBounded_prod_self
File: Mathlib/Topology/Bornology/Constructions.lean

tactic: rcases s.eq_empty_or_nonempty with (rfl | hs)
state_before: α : Type u_1
β : Type ?u.3457
ι : Type ?u.3460
π : ι → Type ?u.3465
inst✝³ : Fintype ι
inst✝² : Bornology α
inst✝¹ : Bornology β
inst✝ : (i : ι) → Bornology (π i)
s : Set α
t : Set β
S : (i : ι) → Set (π i)
⊢ IsBounded (s ×ˢ s) ↔ IsBounded s

tactic: exact (isBounded_prod_of_nonempty (hs.prod hs)).trans (and_self_iff _)
state_before: case inr
α : Type u_1
β : Type ?u.3457
ι : Type ?u.3460
π : ι → Type ?u.3465
inst✝³ : Fintype ι
inst✝² : Bornology α
inst✝¹ : Bornology β
inst✝ : (i : ι) → Bornology (π i)
s : Set α
t : Set β
S : (i : ι) → Set (π i)
hs : Set.Nonempty s
⊢ IsBounded (s ×ˢ s) ↔ IsBounded s

tactic: simp
state_before: case inl
α : Type u_1
β : Type ?u.3457
ι : Type ?u.3460
π : ι → Type ?u.3465
inst✝³ : Fintype ι
inst✝² : Bornology α
inst✝¹ : Bornology β
inst✝ : (i : ι) → Bornology (π i)
t : Set β
S : (i : ι) → Set (π i)
⊢ IsBounded (∅ ×ˢ ∅) ↔ IsBounded ∅
Theorem: ite_mul_one
File: Mathlib/Algebra/Group/Basic.lean

tactic: by_cases h:P <;> simp [h]
state_before: α : Type ?u.1793
β : Type ?u.1796
G : Type ?u.1799
M : Type u
inst✝¹ : MulOneClass M
P : Prop
inst✝ : Decidable P
a b : M
⊢ (if P then a * b else 1) = (if P then a else 1) * if P then b else 1
Theorem: HasDerivAt.div
File: Mathlib/Analysis/Calculus/Deriv/Inv.lean

tactic: rw [← hasDerivWithinAt_univ] at *
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 : Filter 𝕜
𝕜' : Type u_1
inst✝¹ : NontriviallyNormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
c d : 𝕜 → 𝕜'
c' d' : 𝕜'
hc : HasDerivAt c c' x
hd : HasDerivAt d d' x
hx : d x ≠ 0
⊢ HasDerivAt (fun y => c y / d y) ((c' * d x - c x * d') / d x ^ 2) x

tactic: exact hc.div hd hx
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 : Filter 𝕜
𝕜' : Type u_1
inst✝¹ : NontriviallyNormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
c d : 𝕜 → 𝕜'
c' d' : 𝕜'
hc : HasDerivWithinAt c c' univ x
hd : HasDerivWithinAt d d' univ x
hx : d x ≠ 0
⊢ HasDerivWithinAt (fun y => c y / d y) ((c' * d x - c x * d') / d x ^ 2) univ x
Theorem: isPreirreducible_iff_subsingleton
File: Mathlib/Topology/Separation.lean

tactic: refine' ⟨fun h x hx y hy => _, Set.Subsingleton.isPreirreducible⟩
state_before: α : Type u
β : Type v
inst✝³ : TopologicalSpace α
γ : Type ?u.142380
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : T2Space α
S : Set α
⊢ IsPreirreducible S ↔ Set.Subsingleton S

tactic: by_contra e
state_before: α : Type u
β : Type v
inst✝³ : TopologicalSpace α
γ : Type ?u.142380
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : T2Space α
S : Set α
h : IsPreirreducible S
x : α
hx : x ∈ S
y : α
hy : y ∈ S
⊢ x = y

tactic: obtain ⟨U, V, hU, hV, hxU, hyV, h'⟩ := t2_separation e
state_before: α : Type u
β : Type v
inst✝³ : TopologicalSpace α
γ : Type ?u.142380
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : T2Space α
S : Set α
h : IsPreirreducible S
x : α
hx : x ∈ S
y : α
hy : y ∈ S
e : ¬x = y
⊢ False

tactic: exact ((h U V hU hV ⟨x, hx, hxU⟩ ⟨y, hy, hyV⟩).mono <| inter_subset_right _ _).not_disjoint h'
state_before: case intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
inst✝³ : TopologicalSpace α
γ : Type ?u.142380
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : T2Space α
S : Set α
h : IsPreirreducible S
x : α
hx : x ∈ S
y : α
hy : y ∈ S
e : ¬x = y
U V : Set α
hU : IsOpen U
hV : IsOpen V
hxU : x ∈ U
hyV : y ∈ V
h' : Disjoint U V
⊢ False
Theorem: complete_polishSpaceMetric
File: Mathlib/Topology/MetricSpace/Polish.lean

tactic: convert h.complete.choose_spec.2
state_before: α✝ : Type ?u.841
β : Type ?u.844
α : Type u_1
ht : TopologicalSpace α
h : PolishSpace α
⊢ CompleteSpace α

tactic: exact MetricSpace.replaceTopology_eq _ _
state_before: case h.e'_2.h.e'_2.h.e'_2
α✝ : Type ?u.841
β : Type ?u.844
α : Type u_1
ht : TopologicalSpace α
h : PolishSpace α
⊢ polishSpaceMetric α = Exists.choose (_ : ∃ m, UniformSpace.toTopologicalSpace = ht ∧ CompleteSpace α)
Theorem: MeasureTheory.AEDisjoint.exists_disjoint_diff
File: Mathlib/MeasureTheory/Measure/AEDisjoint.lean

tactic: simp
state_before: ι : Type ?u.9675
α : Type u_1
m : MeasurableSpace α
μ : Measure α
s t u v : Set α
h : AEDisjoint μ s t
x : α
hx : x ∈ s \ toMeasurable μ (s ∩ t)
⊢ x ∈ ?m.10357 h \ t

tactic: exact ⟨hx.1, fun hxt => hx.2 <| subset_toMeasurable _ _ ⟨hx.1, hxt⟩⟩
state_before: ι : Type ?u.9675
α : Type u_1
m : MeasurableSpace α
μ : Measure α
s t u v : Set α
h : AEDisjoint μ s t
x : α
hx : x ∈ s \ toMeasurable μ (s ∩ t)
⊢ x ∈ ?m.10357 h ∧ ¬x ∈ t
Theorem: ENNReal.sub_div
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp_rw [div_eq_mul_inv]
state_before: α : Type ?u.262242
β : Type ?u.262245
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < b → b < a → c ≠ 0
⊢ (a - b) / c = a / c - b / c

tactic: exact ENNReal.sub_mul (by simpa using h)
state_before: α : Type ?u.262242
β : Type ?u.262245
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < b → b < a → c ≠ 0
⊢ (a - b) * c⁻¹ = a * c⁻¹ - b * c⁻¹

tactic: simpa using h
state_before: α : Type ?u.262242
β : Type ?u.262245
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < b → b < a → c ≠ 0
⊢ 0 < b → b < a → c⁻¹ ≠ ⊤
Theorem: Filter.tendsto_map'_iff
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [Tendsto, Tendsto, map_map]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.311189
ι : Sort x
f : β → γ
g : α → β
x : Filter α
y : Filter γ
⊢ Tendsto f (map g x) y ↔ Tendsto (f ∘ g) x y
Theorem: frontier_sphere
File: Mathlib/Analysis/NormedSpace/Basic.lean

tactic: rw [isClosed_sphere.frontier_eq, interior_sphere x hr, diff_empty]
state_before: α : Type ?u.90652
β : Type ?u.90655
γ : Type ?u.90658
ι : Type ?u.90661
inst✝⁶ : NormedField α
inst✝⁵ : SeminormedAddCommGroup β
E : Type u_1
inst✝⁴ : SeminormedAddCommGroup E
inst✝³ : NormedSpace α E
F : Type ?u.90692
inst✝² : SeminormedAddCommGroup F
inst✝¹ : NormedSpace α F
inst✝ : NormedSpace ℝ E
x : E
r : ℝ
hr : r ≠ 0
⊢ frontier (sphere x r) = sphere x r
Theorem: Nat.prod_factors_gcd_mul_prod_factors_mul
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: rcases eq_or_ne n 0 with (rfl | hm0)
state_before: β : Type u_1
inst✝ : CommMonoid β
m n : ℕ
f : ℕ → β
⊢ Finset.prod (toFinset (factors (gcd m n))) f * Finset.prod (toFinset (factors (m * n))) f =
    Finset.prod (toFinset (factors m)) f * Finset.prod (toFinset (factors n)) f

tactic: rcases eq_or_ne m 0 with (rfl | hn0)
state_before: case inr
β : Type u_1
inst✝ : CommMonoid β
m n : ℕ
f : ℕ → β
hm0 : n ≠ 0
⊢ Finset.prod (toFinset (factors (gcd m n))) f * Finset.prod (toFinset (factors (m * n))) f =
    Finset.prod (toFinset (factors m)) f * Finset.prod (toFinset (factors n)) f

tactic: rw [← @Finset.prod_union_inter _ _ m.factors.toFinset n.factors.toFinset, mul_comm]
state_before: case inr.inr
β : Type u_1
inst✝ : CommMonoid β
m n : ℕ
f : ℕ → β
hm0 : n ≠ 0
hn0 : m ≠ 0
⊢ Finset.prod (toFinset (factors (gcd m n))) f * Finset.prod (toFinset (factors (m * n))) f =
    Finset.prod (toFinset (factors m)) f * Finset.prod (toFinset (factors n)) f

tactic: congr
state_before: case inr.inr
β : Type u_1
inst✝ : CommMonoid β
m n : ℕ
f : ℕ → β
hm0 : n ≠ 0
hn0 : m ≠ 0
⊢ Finset.prod (toFinset (factors (m * n))) f * Finset.prod (toFinset (factors (gcd m n))) f =
    (∏ x in toFinset (factors m) ∪ toFinset (factors n), f x) * ∏ x in toFinset (factors m) ∩ toFinset (factors n), f x

tactic: simp
state_before: case inl
β : Type u_1
inst✝ : CommMonoid β
m : ℕ
f : ℕ → β
⊢ Finset.prod (toFinset (factors (gcd m 0))) f * Finset.prod (toFinset (factors (m * 0))) f =
    Finset.prod (toFinset (factors m)) f * Finset.prod (toFinset (factors 0)) f

tactic: simp
state_before: case inr.inl
β : Type u_1
inst✝ : CommMonoid β
n : ℕ
f : ℕ → β
hm0 : n ≠ 0
⊢ Finset.prod (toFinset (factors (gcd 0 n))) f * Finset.prod (toFinset (factors (0 * n))) f =
    Finset.prod (toFinset (factors 0)) f * Finset.prod (toFinset (factors n)) f

tactic: apply factors_mul_toFinset <;> assumption
state_before: case inr.inr.e_a.e_s
β : Type u_1
inst✝ : CommMonoid β
m n : ℕ
f : ℕ → β
hm0 : n ≠ 0
hn0 : m ≠ 0
⊢ toFinset (factors (m * n)) = toFinset (factors m) ∪ toFinset (factors n)

tactic: simp only [← support_factorization, factorization_gcd hn0 hm0, Finsupp.support_inf]
state_before: case inr.inr.e_a.e_s
β : Type u_1
inst✝ : CommMonoid β
m n : ℕ
f : ℕ → β
hm0 : n ≠ 0
hn0 : m ≠ 0
⊢ toFinset (factors (gcd m n)) = toFinset (factors m) ∩ toFinset (factors n)
Theorem: Int.bitwise_or
File: Mathlib/Data/Int/Bitwise.lean

tactic: funext m n
state_before: ⊢ bitwise or = lor

tactic: cases' m with m m <;> cases' n with n n <;> try {rfl}
  <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff',
    negSucc.injEq, Bool.true_or, Nat.land']
state_before: case h.h
m n : ℤ
⊢ bitwise or m n = lor m n

tactic: . rw [Nat.bitwise'_swap, Function.swap]
  congr
  funext x y
  cases x <;> cases y <;> rfl
  rfl
state_before: case h.h.ofNat.negSucc
m n : ℕ
⊢ Nat.bitwise' (fun x y => !(x || !y)) m n = Nat.bitwise' (fun a b => a && !b) n m

case h.h.negSucc.ofNat
m n : ℕ
⊢ Nat.bitwise' (fun x y => !(!x || y)) m n = Nat.bitwise' (fun a b => a && !b) m n

case h.h.negSucc.negSucc
m n : ℕ
⊢ Nat.bitwise' (fun x y => !(!x || !y)) m n = Nat.bitwise' and m n

tactic: . congr
  funext x y
  cases x <;> cases y <;> rfl
state_before: case h.h.negSucc.ofNat
m n : ℕ
⊢ Nat.bitwise' (fun x y => !(!x || y)) m n = Nat.bitwise' (fun a b => a && !b) m n

case h.h.negSucc.negSucc
m n : ℕ
⊢ Nat.bitwise' (fun x y => !(!x || !y)) m n = Nat.bitwise' and m n

tactic: . congr
  funext x y
  cases x <;> cases y <;> rfl
state_before: case h.h.negSucc.negSucc
m n : ℕ
⊢ Nat.bitwise' (fun x y => !(!x || !y)) m n = Nat.bitwise' and m n

tactic: rw [Nat.bitwise'_swap, Function.swap]
state_before: case h.h.ofNat.negSucc
m n : ℕ
⊢ Nat.bitwise' (fun x y => !(x || !y)) m n = Nat.bitwise' (fun a b => a && !b) n m

tactic: congr
state_before: case h.h.ofNat.negSucc
m n : ℕ
⊢ Nat.bitwise' (fun y x => !(x || !y)) n m = Nat.bitwise' (fun a b => a && !b) n m

case h.h.ofNat.negSucc
m n : ℕ
⊢ (!(false || !false)) = false

tactic: funext x y
state_before: case h.h.ofNat.negSucc.e_f
m n : ℕ
⊢ (fun y x => !(x || !y)) = fun a b => a && !b

case h.h.ofNat.negSucc
m n : ℕ
⊢ (!(false || !false)) = false

tactic: cases x <;> cases y <;> rfl
state_before: case h.h.ofNat.negSucc.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!(y || !x)) = (x && !y)

case h.h.ofNat.negSucc
m n : ℕ
⊢ (!(false || !false)) = false

tactic: rfl
state_before: case h.h.ofNat.negSucc
m n : ℕ
⊢ (!(false || !false)) = false

tactic: congr
state_before: case h.h.negSucc.ofNat
m n : ℕ
⊢ Nat.bitwise' (fun x y => !(!x || y)) m n = Nat.bitwise' (fun a b => a && !b) m n

tactic: funext x y
state_before: case h.h.negSucc.ofNat.e_f
m n : ℕ
⊢ (fun x y => !(!x || y)) = fun a b => a && !b

tactic: cases x <;> cases y <;> rfl
state_before: case h.h.negSucc.ofNat.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!(!x || y)) = (x && !y)

tactic: congr
state_before: case h.h.negSucc.negSucc
m n : ℕ
⊢ Nat.bitwise' (fun x y => !(!x || !y)) m n = Nat.bitwise' and m n

tactic: funext x y
state_before: case h.h.negSucc.negSucc.e_f
m n : ℕ
⊢ (fun x y => !(!x || !y)) = and

tactic: cases x <;> cases y <;> rfl
state_before: case h.h.negSucc.negSucc.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!(!x || !y)) = (x && y)
Theorem: strictConcaveOn_of_slope_strict_anti_adjacent
File: Mathlib/Analysis/Convex/Slope.lean

tactic: rw [← neg_strictConvexOn_iff]
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) < (f y - f x) / (y - x)
⊢ StrictConcaveOn 𝕜 s f

tactic: refine' strictConvexOn_of_slope_strict_mono_adjacent hs fun hx hz hxy hyz => _
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) < (f y - f x) / (y - x)
⊢ StrictConvexOn 𝕜 s (-f)

tactic: rw [← neg_lt_neg_iff]
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) < (f y - f x) / (y - x)
x✝ y✝ z✝ : 𝕜
hx : x✝ ∈ s
hz : z✝ ∈ s
hxy : x✝ < y✝
hyz : y✝ < z✝
⊢ ((-f) y✝ - (-f) x✝) / (y✝ - x✝) < ((-f) z✝ - (-f) y✝) / (z✝ - y✝)

tactic: simp_rw [← neg_div, neg_sub, Pi.neg_apply, neg_sub_neg]
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) < (f y - f x) / (y - x)
x✝ y✝ z✝ : 𝕜
hx : x✝ ∈ s
hz : z✝ ∈ s
hxy : x✝ < y✝
hyz : y✝ < z✝
⊢ -(((-f) z✝ - (-f) y✝) / (z✝ - y✝)) < -(((-f) y✝ - (-f) x✝) / (y✝ - x✝))

tactic: exact hf hx hz hxy hyz
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) < (f y - f x) / (y - x)
x✝ y✝ z✝ : 𝕜
hx : x✝ ∈ s
hz : z✝ ∈ s
hxy : x✝ < y✝
hyz : y✝ < z✝
⊢ (f z✝ - f y✝) / (z✝ - y✝) < (f y✝ - f x✝) / (y✝ - x✝)
Theorem: CategoryTheory.Localization.comp_liftNatTrans
File: Mathlib/CategoryTheory/Localization/Predicate.lean

tactic: simp only [NatTrans.comp_app, liftNatTrans_app, assoc, Iso.inv_hom_id_app_assoc]
state_before: C : Type u_3
D : Type u_6
inst✝³ : Category C
inst✝² : Category D
L : C ⥤ D
W : MorphismProperty C
E : Type u_4
inst✝¹ : Category E
inst✝ : Functor.IsLocalization L W
F₁ F₂ F₃ : C ⥤ E
F₁' F₂' F₃' : D ⥤ E
h₁ : Lifting L W F₁ F₁'
h₂ : Lifting L W F₂ F₂'
h₃ : Lifting L W F₃ F₃'
τ : F₁ ⟶ F₂
τ' : F₂ ⟶ F₃
X : C
⊢ (liftNatTrans L W F₁ F₂ F₁' F₂' τ ≫ liftNatTrans L W F₂ F₃ F₂' F₃' τ').app (L.obj X) =
    (liftNatTrans L W F₁ F₃ F₁' F₃' (τ ≫ τ')).app (L.obj X)
Theorem: CategoryTheory.uncurry_pre
File: Mathlib/CategoryTheory/Closed/Cartesian.lean

tactic: rw [uncurry_eq, prod_map_pre_app_comp_ev]
state_before: C : Type u
inst✝³ : Category C
A B X✝ X' Y Y' Z : C
inst✝² : HasFiniteProducts C
inst✝¹ : Exponentiable A
f : B ⟶ A
inst✝ : Exponentiable B
X : C
⊢ CartesianClosed.uncurry ((pre f).app X) = prod.map f (𝟙 (A ⟹ X)) ≫ (exp.ev A).app X
Theorem: Nat.Subtype.toFunAux_eq
File: Mathlib/Logic/Denumerable.lean

tactic: rw [toFunAux, List.countp_eq_length_filter]
state_before: α : Type ?u.72269
β : Type ?u.72272
s : Set ℕ
inst✝¹ : Infinite ↑s
inst✝ : DecidablePred fun x => x ∈ s
x : ↑s
⊢ Nat.Subtype.toFunAux x = Finset.card (Finset.filter (fun x => x ∈ s) (Finset.range ↑x))

tactic: rfl
state_before: α : Type ?u.72269
β : Type ?u.72272
s : Set ℕ
inst✝¹ : Infinite ↑s
inst✝ : DecidablePred fun x => x ∈ s
x : ↑s
⊢ List.length (List.filter (fun x => decide (x ∈ s)) (List.range ↑x)) =
    Finset.card (Finset.filter (fun x => x ∈ s) (Finset.range ↑x))
Theorem: Array.getElem_mapIdx
File: Std/Data/Array/Lemmas.lean

tactic: simp_all
state_before: α : Type ?u.57601
β : Type ?u.57642
a : Array α
f : Fin (size a) → α → β
i : Nat
h : i < size (mapIdx a f)
⊢ i < size a
Theorem: LieSubalgebra.ofLe_eq_comap_incl
File: Mathlib/Algebra/Lie/Subalgebra.lean

tactic: ext
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₂
h : K ≤ K'
⊢ ofLe h = comap (incl K') K

tactic: rw [mem_ofLe]
state_before: case h
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₂
h : K ≤ K'
x✝ : { x // x ∈ K' }
⊢ x✝ ∈ ofLe h ↔ x✝ ∈ comap (incl K') K

tactic: rfl
state_before: case h
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₂
h : K ≤ K'
x✝ : { x // x ∈ K' }
⊢ ↑x✝ ∈ K ↔ x✝ ∈ comap (incl K') K
Theorem: Cardinal.lt_wf
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: let f : ι → Cardinal := Subtype.val
state_before: α β : Type u
a : Cardinal
h : ¬Acc (fun x x_1 => x < x_1) a
ι : Type (?u.60636 + 1) := { c // ¬Acc (fun x x_1 => x < x_1) c }
⊢ False

tactic: haveI hι : Nonempty ι := ⟨⟨_, h⟩⟩
state_before: α β : Type u
a : Cardinal
h : ¬Acc (fun x x_1 => x < x_1) a
ι : Type (?u.60636 + 1) := { c // ¬Acc (fun x x_1 => x < x_1) c }
f : ι → Cardinal := Subtype.val
⊢ False

tactic: refine hc (Acc.intro _ fun j h' => byContradiction fun hj => h'.2 ?_)
state_before: case intro.mk.intro
α β : Type u
a : Cardinal
h : ¬Acc (fun x x_1 => x < x_1) a
ι : Type (u + 1) := { c // ¬Acc (fun x x_1 => x < x_1) c }
f : ι → Cardinal := Subtype.val
hι : Nonempty ι
c : Cardinal
hc : ¬Acc (fun x x_1 => x < x_1) c
h_1 : (j : ι) → Quotient.out (f { val := c, property := hc }) ↪ Quotient.out (f j)
⊢ False

tactic: have : (#_) ≤ (#_) := ⟨h_1 ⟨j, hj⟩⟩
state_before: case intro.mk.intro
α β : Type u
a : Cardinal
h : ¬Acc (fun x x_1 => x < x_1) a
ι : Type (u + 1) := { c // ¬Acc (fun x x_1 => x < x_1) c }
f : ι → Cardinal := Subtype.val
hι : Nonempty ι
c : Cardinal
hc : ¬Acc (fun x x_1 => x < x_1) c
h_1 : (j : ι) → Quotient.out (f { val := c, property := hc }) ↪ Quotient.out (f j)
j : Cardinal
h' : j < c
hj : ¬Acc (fun x x_1 => x < x_1) j
⊢ Quotient.liftOn₂ c j (fun α β => Nonempty (α ↪ β)) instLECardinal.proof_1

tactic: simpa only [mk_out] using this
state_before: case intro.mk.intro
α β : Type u
a : Cardinal
h : ¬Acc (fun x x_1 => x < x_1) a
ι : Type (u + 1) := { c // ¬Acc (fun x x_1 => x < x_1) c }
f : ι → Cardinal := Subtype.val
hι : Nonempty ι
c : Cardinal
hc : ¬Acc (fun x x_1 => x < x_1) c
h_1 : (j : ι) → Quotient.out (f { val := c, property := hc }) ↪ Quotient.out (f j)
j : Cardinal
h' : j < c
hj : ¬Acc (fun x x_1 => x < x_1) j
this : (#Quotient.out (f { val := c, property := hc })) ≤ (#Quotient.out (f { val := j, property := hj }))
⊢ Quotient.liftOn₂ c j (fun α β => Nonempty (α ↪ β)) instLECardinal.proof_1
Theorem: Cardinal.exists_infinite_fiber
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: simp_rw [Cardinal.infinite_iff] at w'⊢
state_before: α✝ : Type ?u.149199
r : α✝ → α✝ → Prop
β α : Type u_1
f : β → α
w : (#α) < (#β)
w' : Infinite α
⊢ ∃ a, Infinite ↑(f ⁻¹' {a})

tactic: cases' infinite_pigeonhole_card_lt f w w' with a ha
state_before: α✝ : Type ?u.149199
r : α✝ → α✝ → Prop
β α : Type u_1
f : β → α
w : (#α) < (#β)
w' : ℵ₀ ≤ (#α)
⊢ ∃ a, ℵ₀ ≤ (#↑(f ⁻¹' {a}))

tactic: exact ⟨a, w'.trans ha.le⟩
state_before: case intro
α✝ : Type ?u.149199
r : α✝ → α✝ → Prop
β α : Type u_1
f : β → α
w : (#α) < (#β)
w' : ℵ₀ ≤ (#α)
a : α
ha : (#α) < (#↑(f ⁻¹' {a}))
⊢ ∃ a, ℵ₀ ≤ (#↑(f ⁻¹' {a}))
Theorem: List.mem_nil_iff
File: Std/Data/List/Lemmas.lean

tactic: simp
state_before: α : Type u_1
a : α
⊢ a ∈ [] ↔ False
Theorem: PadicSeq.not_equiv_zero_const_of_nonzero
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: simpa using h
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
q : ℚ
hq : q ≠ 0
h : LimZero (const (padicNorm p) q - 0)
⊢ LimZero (const (padicNorm (?m.11534 hq h)) q)
Theorem: SimpleGraph.Walk.cons_isPath_iff
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: constructor <;> simp (config := { contextual := true }) [isPath_def]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
h : Adj G u v
p : Walk G v w
⊢ IsPath (cons h p) ↔ IsPath p ∧ ¬u ∈ support p