tasksource/leandojo huggingface dataset:
Theorem: MeasurableEmbedding.measurable_rangeSplitting
File: Mathlib/MeasureTheory/MeasurableSpace.lean

tactic: rwa [preimage_rangeSplitting hf.injective,
  ← (subtype_coe hf.measurableSet_range).measurableSet_image, ← image_comp,
  coe_comp_rangeFactorization, hf.measurableSet_image]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.381096
δ : Type ?u.381099
δ' : Type ?u.381102
ι : Sort uι
s✝ t u : Set α
mα : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
f : α → β
g : β → γ
hf : MeasurableEmbedding f
s : Set α
hs : MeasurableSet s
⊢ MeasurableSet (rangeSplitting f ⁻¹' s)
Theorem: ENNReal.zpow_lt_top
File: Mathlib/Data/Real/ENNReal.lean

tactic: cases n
state_before: α : Type ?u.434875
β : Type ?u.434878
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
h'a : a ≠ ⊤
n : ℤ
⊢ a ^ n < ⊤

tactic: exact ENNReal.pow_lt_top h'a.lt_top _
state_before: case ofNat
α : Type ?u.434875
β : Type ?u.434878
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
h'a : a ≠ ⊤
a✝ : ℕ
⊢ a ^ Int.ofNat a✝ < ⊤

tactic: simp only [ENNReal.pow_pos ha.bot_lt, zpow_negSucc, inv_lt_top]
state_before: case negSucc
α : Type ?u.434875
β : Type ?u.434878
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
h'a : a ≠ ⊤
a✝ : ℕ
⊢ a ^ Int.negSucc a✝ < ⊤
Theorem: Nat.pow_length_le_mul_ofDigits
File: Mathlib/Data/Nat/Digits.lean

tactic: rw [← List.dropLast_append_getLast hl]
state_before: n b : ℕ
l : List ℕ
hl : l ≠ []
hl2 : List.getLast l hl ≠ 0
⊢ (b + 2) ^ List.length l ≤ (b + 2) * ofDigits (b + 2) l

tactic: simp only [List.length_append, List.length, zero_add, List.length_dropLast, ofDigits_append,
  List.length_dropLast, ofDigits_singleton, add_comm (l.length - 1), pow_add, pow_one]
state_before: n b : ℕ
l : List ℕ
hl : l ≠ []
hl2 : List.getLast l hl ≠ 0
⊢ (b + 2) ^ List.length (List.dropLast l ++ [List.getLast l hl]) ≤
    (b + 2) * ofDigits (b + 2) (List.dropLast l ++ [List.getLast l hl])

tactic: apply Nat.mul_le_mul_left
state_before: n b : ℕ
l : List ℕ
hl : l ≠ []
hl2 : List.getLast l hl ≠ 0
⊢ (b + 2) * (b + 2) ^ (List.length l - 1) ≤
    (b + 2) * (ofDigits (b + 2) (List.dropLast l) + (b + 2) ^ (List.length l - 1) * List.getLast l hl)

tactic: refine' le_trans _ (Nat.le_add_left _ _)
state_before: case h
n b : ℕ
l : List ℕ
hl : l ≠ []
hl2 : List.getLast l hl ≠ 0
⊢ (b + 2) ^ (List.length l - 1) ≤ ofDigits (b + 2) (List.dropLast l) + (b + 2) ^ (List.length l - 1) * List.getLast l hl

tactic: have : 0 < l.getLast hl := by rwa [pos_iff_ne_zero]
state_before: case h
n b : ℕ
l : List ℕ
hl : l ≠ []
hl2 : List.getLast l hl ≠ 0
⊢ (b + 2) ^ (List.length l - 1) ≤ (b + 2) ^ (List.length l - 1) * List.getLast l hl

tactic: convert Nat.mul_le_mul_left ((b + 2) ^ (l.length - 1)) this using 1
state_before: case h
n b : ℕ
l : List ℕ
hl : l ≠ []
hl2 : List.getLast l hl ≠ 0
this : 0 < List.getLast l hl
⊢ (b + 2) ^ (List.length l - 1) ≤ (b + 2) ^ (List.length l - 1) * List.getLast l hl

tactic: rw [Nat.mul_one]
state_before: case h.e'_3
n b : ℕ
l : List ℕ
hl : l ≠ []
hl2 : List.getLast l hl ≠ 0
this : 0 < List.getLast l hl
⊢ (b + 2) ^ (List.length l - 1) = (b + 2) ^ (List.length l - 1) * succ 0

tactic: rwa [pos_iff_ne_zero]
state_before: n b : ℕ
l : List ℕ
hl : l ≠ []
hl2 : List.getLast l hl ≠ 0
⊢ 0 < List.getLast l hl
Theorem: DirectedOn.convex_sUnion
File: Mathlib/Analysis/Convex/Basic.lean

tactic: rw [sUnion_eq_iUnion]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.8386
β : Type ?u.8389
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
s : Set E
x : E
c : Set (Set E)
hdir : DirectedOn (fun x x_1 => x ⊆ x_1) c
hc : ∀ ⦃A : Set E⦄, A ∈ c → Convex 𝕜 A
⊢ Convex 𝕜 (⋃₀ c)

tactic: exact (directedOn_iff_directed.1 hdir).convex_iUnion fun A => hc A.2
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.8386
β : Type ?u.8389
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
s : Set E
x : E
c : Set (Set E)
hdir : DirectedOn (fun x x_1 => x ⊆ x_1) c
hc : ∀ ⦃A : Set E⦄, A ∈ c → Convex 𝕜 A
⊢ Convex 𝕜 (⋃ (i : ↑c), ↑i)
Theorem: MeasureTheory.AEStronglyMeasurable.nullMeasurableSet_lt
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: apply
  (hf.stronglyMeasurable_mk.measurableSet_lt hg.stronglyMeasurable_mk).nullMeasurableSet.congr
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.342741
ι : Type ?u.342744
inst✝⁵ : Countable ι
m : MeasurableSpace α
μ : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
f✝ g✝ : α → β
inst✝² : LinearOrder β
inst✝¹ : OrderClosedTopology β
inst✝ : PseudoMetrizableSpace β
f g : α → β
hf : AEStronglyMeasurable f μ
hg : AEStronglyMeasurable g μ
⊢ NullMeasurableSet {a | f a < g a}

tactic: filter_upwards [hf.ae_eq_mk, hg.ae_eq_mk] with x hfx hgx
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.342741
ι : Type ?u.342744
inst✝⁵ : Countable ι
m : MeasurableSpace α
μ : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
f✝ g✝ : α → β
inst✝² : LinearOrder β
inst✝¹ : OrderClosedTopology β
inst✝ : PseudoMetrizableSpace β
f g : α → β
hf : AEStronglyMeasurable f μ
hg : AEStronglyMeasurable g μ
⊢ {a | AEStronglyMeasurable.mk f hf a < AEStronglyMeasurable.mk g hg a} =ᶠ[ae μ] {a | f a < g a}

tactic: change (hf.mk f x < hg.mk g x) = (f x < g x)
state_before: case h
α : Type u_2
β : Type u_1
γ : Type ?u.342741
ι : Type ?u.342744
inst✝⁵ : Countable ι
m : MeasurableSpace α
μ : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
f✝ g✝ : α → β
inst✝² : LinearOrder β
inst✝¹ : OrderClosedTopology β
inst✝ : PseudoMetrizableSpace β
f g : α → β
hf : AEStronglyMeasurable f μ
hg : AEStronglyMeasurable g μ
x : α
hfx : f x = AEStronglyMeasurable.mk f hf x
hgx : g x = AEStronglyMeasurable.mk g hg x
⊢ setOf (fun a => AEStronglyMeasurable.mk f hf a < AEStronglyMeasurable.mk g hg a) x = setOf (fun a => f a < g a) x

tactic: simp only [hfx, hgx]
state_before: case h
α : Type u_2
β : Type u_1
γ : Type ?u.342741
ι : Type ?u.342744
inst✝⁵ : Countable ι
m : MeasurableSpace α
μ : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
f✝ g✝ : α → β
inst✝² : LinearOrder β
inst✝¹ : OrderClosedTopology β
inst✝ : PseudoMetrizableSpace β
f g : α → β
hf : AEStronglyMeasurable f μ
hg : AEStronglyMeasurable g μ
x : α
hfx : f x = AEStronglyMeasurable.mk f hf x
hgx : g x = AEStronglyMeasurable.mk g hg x
⊢ (AEStronglyMeasurable.mk f hf x < AEStronglyMeasurable.mk g hg x) = (f x < g x)
Theorem: hasSum_mul_right_iff
File: Mathlib/Topology/Algebra/InfiniteSum/Ring.lean

tactic: simpa only [mul_inv_cancel_right₀ h] using H.mul_right a₂⁻¹
state_before: ι : Type u_2
κ : Type ?u.10143
R : Type ?u.10146
α : Type u_1
inst✝² : DivisionSemiring α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSemiring α
f g : ι → α
a a₁ a₂ : α
h : a₂ ≠ 0
H : HasSum (fun i => f i * a₂) (a₁ * a₂)
⊢ HasSum f a₁
Theorem: Int.fract_int_nat
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [add_comm, fract_add_nat]
state_before: F : Type ?u.150154
α : Type u_1
β : Type ?u.150160
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ : α
n : ℕ
a : α
⊢ fract (↑n + a) = fract a
Theorem: Nat.Prime.mod_two_eq_one_iff_ne_two
File: Mathlib/Data/Nat/Prime.lean

tactic: refine' ⟨fun h hf => _, (Nat.Prime.eq_two_or_odd <| @Fact.out p.Prime _).resolve_left⟩
state_before: p : ℕ
inst✝ : Fact (Prime p)
⊢ p % 2 = 1 ↔ p ≠ 2

tactic: rw [hf] at h
state_before: p : ℕ
inst✝ : Fact (Prime p)
h : p % 2 = 1
hf : p = 2
⊢ False

tactic: simp at h
state_before: p : ℕ
inst✝ : Fact (Prime p)
h : 2 % 2 = 1
hf : p = 2
⊢ False
Theorem: div_self_le_one
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: simp [h]
state_before: ι : Type ?u.34425
α : Type u_1
β : Type ?u.34431
inst✝ : LinearOrderedSemifield α
a✝ b c d e : α
m n : ℤ
a : α
h : a = 0
⊢ a / a ≤ 1

tactic: simp [h]
state_before: ι : Type ?u.34425
α : Type u_1
β : Type ?u.34431
inst✝ : LinearOrderedSemifield α
a✝ b c d e : α
m n : ℤ
a : α
h : ¬a = 0
⊢ a / a ≤ 1
Theorem: toTopologicalSpace_sInf
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [sInf_eq_iInf]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.143853
s : Set (UniformSpace α)
⊢ UniformSpace.toTopologicalSpace = ⨅ (i : UniformSpace α) (_ : i ∈ s), UniformSpace.toTopologicalSpace

tactic: simp only [← toTopologicalSpace_iInf]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.143853
s : Set (UniformSpace α)
⊢ UniformSpace.toTopologicalSpace = ⨅ (i : UniformSpace α) (_ : i ∈ s), UniformSpace.toTopologicalSpace
Theorem: CategoryTheory.Limits.IsLimit.lift_comp_conePointsIsoOfNatIso_hom
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: simp
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F✝ : J ⥤ C
t✝ : Cone F✝
F G : J ⥤ C
r s : Cone F
t : Cone G
P : IsLimit s
Q : IsLimit t
w : F ≅ G
⊢ ∀ (j : J), (lift P r ≫ (conePointsIsoOfNatIso P Q w).hom) ≫ t.π.app j = map r Q w.hom ≫ t.π.app j
Theorem: Finset.partiallyWellOrderedOn_sup
File: Mathlib/Order/WellFoundedSet.lean

tactic: simp
state_before: ι : Type u_1
α : Type u_2
β : Type ?u.118573
r : α → α → Prop
s : Finset ι
f : ι → Set α
⊢ Set.PartiallyWellOrderedOn (sup ∅ f) r ↔ ∀ (i : ι), i ∈ ∅ → Set.PartiallyWellOrderedOn (f i) r

tactic: simp [-sup_set_eq_biUnion, hs]
state_before: ι : Type u_1
α : Type u_2
β : Type ?u.118573
r : α → α → Prop
s✝ : Finset ι
f : ι → Set α
a : ι
s : Finset ι
ha : ¬a ∈ s
hs : Set.PartiallyWellOrderedOn (sup s f) r ↔ ∀ (i : ι), i ∈ s → Set.PartiallyWellOrderedOn (f i) r
⊢ Set.PartiallyWellOrderedOn (sup (cons a s ha) f) r ↔ ∀ (i : ι), i ∈ cons a s ha → Set.PartiallyWellOrderedOn (f i) r
Theorem: BilinForm.sub_left
File: Mathlib/LinearAlgebra/BilinearForm.lean

tactic: rw [sub_eq_add_neg, sub_eq_add_neg, add_left, neg_left]
state_before: R : Type ?u.56682
M : Type ?u.56685
inst✝¹⁴ : Semiring R
inst✝¹³ : AddCommMonoid M
inst✝¹² : Module R M
R₁ : Type u_1
M₁ : Type u_2
inst✝¹¹ : Ring R₁
inst✝¹⁰ : AddCommGroup M₁
inst✝⁹ : Module R₁ M₁
R₂ : Type ?u.57333
M₂ : Type ?u.57336
inst✝⁸ : CommSemiring R₂
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Module R₂ M₂
R₃ : Type ?u.57523
M₃ : Type ?u.57526
inst✝⁵ : CommRing R₃
inst✝⁴ : AddCommGroup M₃
inst✝³ : Module R₃ M₃
V : Type ?u.58114
K : Type ?u.58117
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
x y z : M₁
⊢ bilin B₁ (x - y) z = bilin B₁ x z - bilin B₁ y z
Theorem: Bool.and_assoc
File: src/lean/Init/SimpLemmas.lean

tactic: cases a <;> cases b <;> cases c <;> decide
state_before: a b c : Bool
⊢ (a && b && c) = (a && (b && c))
Theorem: Dfinsupp.filter_zero
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : (i : ι) → Zero (β i)
p : ι → Prop
inst✝ : DecidablePred p
⊢ filter p 0 = 0

tactic: simp
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : (i : ι) → Zero (β i)
p : ι → Prop
inst✝ : DecidablePred p
i✝ : ι
⊢ ↑(filter p 0) i✝ = ↑0 i✝
Theorem: dist_triangle4_right
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [add_right_comm, dist_comm y₁]
state_before: α : Type u
β : Type v
X : Type ?u.10931
ι : Type ?u.10934
inst✝ : PseudoMetricSpace α
x₁ y₁ x₂ y₂ : α
⊢ dist x₁ y₁ ≤ dist x₁ x₂ + dist y₁ y₂ + dist x₂ y₂

tactic: apply dist_triangle4
state_before: α : Type u
β : Type v
X : Type ?u.10931
ι : Type ?u.10934
inst✝ : PseudoMetricSpace α
x₁ y₁ x₂ y₂ : α
⊢ dist x₁ y₁ ≤ dist x₁ x₂ + dist x₂ y₂ + dist y₂ y₁
Theorem: Bool.not_true
File: src/lean/Init/SimpLemmas.lean

tactic: decide
state_before: ⊢ (!true) = false
Theorem: Mathlib.Tactic.Ring.inv_congr
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R✝ : Type ?u.398680
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝¹ : CommSemiring R✝
R : Type u_1
inst✝ : DivisionRing R
a a' b : R
x✝¹ : a = a'
x✝ : a'⁻¹ = b
⊢ a⁻¹ = b

tactic: rfl
state_before: u : Lean.Level
R✝ : Type ?u.398680
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝¹ : CommSemiring R✝
R : Type u_1
inst✝ : DivisionRing R
a' : R
⊢ a'⁻¹ = a'⁻¹
Theorem: NonemptyInterval.length_sub
File: Mathlib/Algebra/Order/Interval.lean

tactic: simp [sub_eq_add_neg]
state_before: ι : Type ?u.375170
α : Type u_1
inst✝ : OrderedAddCommGroup α
s t : NonemptyInterval α
a : α
⊢ length (s - t) = length s + length t
Theorem: Set.indicator_eq_one_iff_mem
File: Mathlib/Algebra/IndicatorFunction.lean

tactic: classical simp [indicator_apply, imp_false]
state_before: α : Type u_1
β : Type ?u.146422
ι : Type ?u.146425
M : Type u_2
N : Type ?u.146431
inst✝¹ : MulZeroOneClass M
inst✝ : Nontrivial M
U : Set α
x : α
⊢ indicator U 1 x = 1 ↔ x ∈ U

tactic: simp [indicator_apply, imp_false]
state_before: α : Type u_1
β : Type ?u.146422
ι : Type ?u.146425
M : Type u_2
N : Type ?u.146431
inst✝¹ : MulZeroOneClass M
inst✝ : Nontrivial M
U : Set α
x : α
⊢ indicator U 1 x = 1 ↔ x ∈ U
Theorem: Finset.sum_centroidWeights_eq_one_of_card_ne_zero
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: simp only [centroidWeights_apply, sum_const, nsmul_eq_mul, ne_eq, Nat.cast_eq_zero, card_eq_zero]
state_before: k : Type u_1
V : Type ?u.468798
P : Type ?u.468801
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type ?u.469320
s₂ : Finset ι₂
inst✝ : CharZero k
h : card s ≠ 0
⊢ ∑ i in s, centroidWeights k s i = 1

tactic: refine mul_inv_cancel ?_
state_before: k : Type u_1
V : Type ?u.468798
P : Type ?u.468801
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type ?u.469320
s₂ : Finset ι₂
inst✝ : CharZero k
h : card s ≠ 0
⊢ ↑(card s) * (↑(card s))⁻¹ = 1

tactic: norm_cast
state_before: k : Type u_1
V : Type ?u.468798
P : Type ?u.468801
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type ?u.469320
s₂ : Finset ι₂
inst✝ : CharZero k
h : card s ≠ 0
⊢ ↑(card s) ≠ 0
Theorem: Filter.prod_sup
File: Mathlib/Order/Filter/Prod.lean

tactic: dsimp only [SProd.sprod]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.5866
δ : Type ?u.5869
ι : Sort ?u.5872
s : Set α
t : Set β
f✝ : Filter α
g : Filter β
f : Filter α
g₁ g₂ : Filter β
⊢ f ×ˢ (g₁ ⊔ g₂) = f ×ˢ g₁ ⊔ f ×ˢ g₂

tactic: rw [Filter.prod, comap_sup, inf_sup_left, ← Filter.prod, ← Filter.prod]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.5866
δ : Type ?u.5869
ι : Sort ?u.5872
s : Set α
t : Set β
f✝ : Filter α
g : Filter β
f : Filter α
g₁ g₂ : Filter β
⊢ Filter.prod f (g₁ ⊔ g₂) = Filter.prod f g₁ ⊔ Filter.prod f g₂
Theorem: CategoryTheory.SimplicialObject.δ_comp_δ_self
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: dsimp [δ]
state_before: C : Type u
inst✝ : Category C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
⊢ δ X (↑Fin.castSucc i) ≫ δ X i = δ X (Fin.succ i) ≫ δ X i

tactic: simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_δ_self]
state_before: C : Type u
inst✝ : Category C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
⊢ X.map (SimplexCategory.δ (↑Fin.castSucc i)).op ≫ X.map (SimplexCategory.δ i).op =
    X.map (SimplexCategory.δ (Fin.succ i)).op ≫ X.map (SimplexCategory.δ i).op
Theorem: Finset.sum_filter_count_eq_countp
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simp [Finset.sum, sum_map_count_dedup_filter_eq_countp p l]
state_before: ι : Type ?u.516018
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝² : CommMonoid β
inst✝¹ : DecidableEq α
p : α → Prop
inst✝ : DecidablePred p
l : List α
⊢ ∑ x in filter p (toFinset l), count x l = countp (fun b => decide (p b)) l
Theorem: CategoryTheory.Limits.PushoutCocone.coequalizer_ext
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: rw [← t.w fst, Category.assoc, Category.assoc, h₀]
state_before: C : Type u
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
W✝ X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
t : PushoutCocone f g
W : C
k l : t.pt ⟶ W
h₀ : inl t ≫ k = inl t ≫ l
h₁ : inr t ≫ k = inr t ≫ l
⊢ t.ι.app none ≫ k = t.ι.app none ≫ l
Theorem: IsLocalMinOn.hasFDerivWithinAt_eq_zero
File: Mathlib/Analysis/Calculus/LocalExtr.lean

tactic: simpa using h.neg.hasFDerivWithinAt_eq_zero hf.neg hy hy'
state_before: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
a : E
f' : E →L[ℝ] ℝ
s : Set E
h : IsLocalMinOn f s a
hf : HasFDerivWithinAt f f' s a
y : E
hy : y ∈ posTangentConeAt s a
hy' : -y ∈ posTangentConeAt s a
⊢ ↑f' y = 0
Theorem: Finset.prod_one_sub_ordered
File: Mathlib/Algebra/BigOperators/Ring.lean

tactic: rw [prod_sub_ordered]
state_before: α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
b : β
f✝ g : α → β
inst✝² : CommSemiring β
ι : Type u_1
R : Type u_2
inst✝¹ : CommRing R
inst✝ : LinearOrder ι
s : Finset ι
f : ι → R
⊢ ∏ i in s, (1 - f i) = 1 - ∑ i in s, f i * ∏ j in filter (fun x => x < i) s, (1 - f j)

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
b : β
f✝ g : α → β
inst✝² : CommSemiring β
ι : Type u_1
R : Type u_2
inst✝¹ : CommRing R
inst✝ : LinearOrder ι
s : Finset ι
f : ι → R
⊢ ∏ i in s, 1 - ∑ i in s, (f i * ∏ j in filter (fun x => x < i) s, (1 - f j)) * ∏ j in filter (fun j => i < j) s, 1 =
    1 - ∑ i in s, f i * ∏ j in filter (fun x => x < i) s, (1 - f j)
Theorem: SimpleGraph.chromaticNumber_top_eq_zero_of_infinite
File: Mathlib/Combinatorics/SimpleGraph/Coloring.lean

tactic: let n := (⊤ : SimpleGraph V).chromaticNumber
state_before: V✝ : Type u
G : SimpleGraph V✝
α : Type v
C : Coloring G α
V : Type u_1
inst✝ : Infinite V
⊢ chromaticNumber ⊤ = 0

tactic: by_contra hc
state_before: V✝ : Type u
G : SimpleGraph V✝
α : Type v
C : Coloring G α
V : Type u_1
inst✝ : Infinite V
n : ℕ := chromaticNumber ⊤
⊢ chromaticNumber ⊤ = 0

tactic: replace hc := pos_iff_ne_zero.mpr hc
state_before: V✝ : Type u
G : SimpleGraph V✝
α : Type v
C : Coloring G α
V : Type u_1
inst✝ : Infinite V
n : ℕ := chromaticNumber ⊤
hc : ¬chromaticNumber ⊤ = 0
⊢ False

tactic: apply Nat.not_succ_le_self n
state_before: V✝ : Type u
G : SimpleGraph V✝
α : Type v
C : Coloring G α
V : Type u_1
inst✝ : Infinite V
n : ℕ := chromaticNumber ⊤
hc : 0 < chromaticNumber ⊤
⊢ False

tactic: convert_to (⊤ : SimpleGraph { m | m < n + 1 }).chromaticNumber ≤ _
state_before: V✝ : Type u
G : SimpleGraph V✝
α : Type v
C : Coloring G α
V : Type u_1
inst✝ : Infinite V
n : ℕ := chromaticNumber ⊤
hc : 0 < chromaticNumber ⊤
⊢ Nat.succ n ≤ n

tactic: refine' (colorable_of_chromaticNumber_pos hc).chromaticNumber_mono_of_embedding _
state_before: V✝ : Type u
G : SimpleGraph V✝
α : Type v
C : Coloring G α
V : Type u_1
inst✝ : Infinite V
n : ℕ := chromaticNumber ⊤
hc : 0 < chromaticNumber ⊤
⊢ chromaticNumber ⊤ ≤ n

tactic: apply Embedding.completeGraph
state_before: V✝ : Type u
G : SimpleGraph V✝
α : Type v
C : Coloring G α
V : Type u_1
inst✝ : Infinite V
n : ℕ := chromaticNumber ⊤
hc : 0 < chromaticNumber ⊤
⊢ ⊤ ↪g ⊤

tactic: exact (Function.Embedding.subtype _).trans (Infinite.natEmbedding V)
state_before: case f
V✝ : Type u
G : SimpleGraph V✝
α : Type v
C : Coloring G α
V : Type u_1
inst✝ : Infinite V
n : ℕ := chromaticNumber ⊤
hc : 0 < chromaticNumber ⊤
⊢ ↑{m | m < n + 1} ↪ V

tactic: rw [SimpleGraph.chromaticNumber_top, Fintype.card_ofFinset,
    Finset.card_range, Nat.succ_eq_add_one]
state_before: case h.e'_3
V✝ : Type u
G : SimpleGraph V✝
α : Type v
C : Coloring G α
V : Type u_1
inst✝ : Infinite V
n : ℕ := chromaticNumber ⊤
hc : 0 < chromaticNumber ⊤
⊢ Nat.succ n = chromaticNumber ⊤
Theorem: Pell.ysq_dvd_yy
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: simp [_root_.pow_succ]
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ yn a1 n * yn a1 n ∣ yn a1 n ^ 3

tactic: simp [mul_dvd_mul_left, mul_assoc]
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ yn a1 n * yn a1 n ∣ yn a1 n * xn a1 n ^ (yn a1 n - 1) * yn a1 n
Theorem: PythagoreanTriple.coprime_of_coprime
File: Mathlib/NumberTheory/PythagoreanTriples.lean

tactic: by_contra H
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : Int.gcd x y = 1
⊢ Int.gcd y z = 1

tactic: obtain ⟨p, hp, hpy, hpz⟩ := Nat.Prime.not_coprime_iff_dvd.mp H
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : Int.gcd x y = 1
H : ¬Int.gcd y z = 1
⊢ False

tactic: apply hp.not_dvd_one
state_before: case intro.intro.intro
x y z : ℤ
h : PythagoreanTriple x y z
hc : Int.gcd x y = 1
H : ¬Int.gcd y z = 1
p : ℕ
hp : Nat.Prime p
hpy : p ∣ Int.natAbs y
hpz : p ∣ Int.natAbs z
⊢ False

tactic: rw [← hc]
state_before: case intro.intro.intro
x y z : ℤ
h : PythagoreanTriple x y z
hc : Int.gcd x y = 1
H : ¬Int.gcd y z = 1
p : ℕ
hp : Nat.Prime p
hpy : p ∣ Int.natAbs y
hpz : p ∣ Int.natAbs z
⊢ p ∣ 1

tactic: apply Nat.dvd_gcd (Int.Prime.dvd_natAbs_of_coe_dvd_sq hp _ _) hpy
state_before: case intro.intro.intro
x y z : ℤ
h : PythagoreanTriple x y z
hc : Int.gcd x y = 1
H : ¬Int.gcd y z = 1
p : ℕ
hp : Nat.Prime p
hpy : p ∣ Int.natAbs y
hpz : p ∣ Int.natAbs z
⊢ p ∣ Int.gcd x y

tactic: rw [sq, eq_sub_of_add_eq h]
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : Int.gcd x y = 1
H : ¬Int.gcd y z = 1
p : ℕ
hp : Nat.Prime p
hpy : p ∣ Int.natAbs y
hpz : p ∣ Int.natAbs z
⊢ ↑p ∣ x ^ 2

tactic: rw [← Int.coe_nat_dvd_left] at hpy hpz
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : Int.gcd x y = 1
H : ¬Int.gcd y z = 1
p : ℕ
hp : Nat.Prime p
hpy : p ∣ Int.natAbs y
hpz : p ∣ Int.natAbs z
⊢ ↑p ∣ z * z - y * y

tactic: exact dvd_sub (hpz.mul_right _) (hpy.mul_right _)
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : Int.gcd x y = 1
H : ¬Int.gcd y z = 1
p : ℕ
hp : Nat.Prime p
hpy : ↑p ∣ y
hpz : ↑p ∣ z
⊢ ↑p ∣ z * z - y * y
Theorem: Set.Icc_eq_empty_iff
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: rw [← not_nonempty_iff_eq_empty, not_iff_not, nonempty_Icc]
state_before: α : Type u_1
β : Type ?u.27512
inst✝ : Preorder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ Icc a b = ∅ ↔ ¬a ≤ b
Theorem: Finset.filter_union_right
File: Mathlib/Data/Finset/Basic.lean

tactic: simp [mem_filter, mem_union, ←and_or_left]
state_before: α : Type u_1
β : Type ?u.369340
γ : Type ?u.369343
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
inst✝ : DecidableEq α
s : Finset α
x : α
⊢ x ∈ filter p s ∪ filter q s ↔ x ∈ filter (fun x => p x ∨ q x) s
Theorem: Subspace.dualLift_of_subtype
File: Mathlib/LinearAlgebra/Dual.lean

tactic: erw [ofIsCompl_left_apply _ w]
state_before: K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W : Subspace K V
φ : Module.Dual K { x // x ∈ W }
w : { x // x ∈ W }
⊢ ↑(↑(dualLift W) φ) ↑w = ↑φ w

tactic: rfl
state_before: K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W : Subspace K V
φ : Module.Dual K { x // x ∈ W }
w : { x // x ∈ W }
⊢ ↑(↑(inl K (Module.Dual K { x // x ∈ W })
                ({ x // x ∈ ↑(Classical.indefiniteDescription (fun x => IsCompl W x) (_ : ∃ q, IsCompl W q)) } →ₗ[K] K))
            φ).fst
      w =
    ↑φ w