tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.mono_of_mono
File: Mathlib/CategoryTheory/Category/Basic.lean

tactic: constructor
state_before: C : Type u
inst✝¹ : Category C
X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : Mono (f ≫ g)
⊢ Mono f

tactic: intro Z a b w
state_before: case right_cancellation
C : Type u
inst✝¹ : Category C
X✝ Y✝ Z✝ X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : Mono (f ≫ g)
⊢ ∀ {Z : C} (g h : Z ⟶ X), g ≫ f = h ≫ f → g = h

tactic: replace w := congr_arg (fun k => k ≫ g) w
state_before: case right_cancellation
C : Type u
inst✝¹ : Category C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
g : Y ⟶ Z✝
inst✝ : Mono (f ≫ g)
Z : C
a b : Z ⟶ X
w : a ≫ f = b ≫ f
⊢ a = b

tactic: dsimp at w
state_before: case right_cancellation
C : Type u
inst✝¹ : Category C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
g : Y ⟶ Z✝
inst✝ : Mono (f ≫ g)
Z : C
a b : Z ⟶ X
w : (fun k => k ≫ g) (a ≫ f) = (fun k => k ≫ g) (b ≫ f)
⊢ a = b

tactic: rw [Category.assoc, Category.assoc] at w
state_before: case right_cancellation
C : Type u
inst✝¹ : Category C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
g : Y ⟶ Z✝
inst✝ : Mono (f ≫ g)
Z : C
a b : Z ⟶ X
w : (a ≫ f) ≫ g = (b ≫ f) ≫ g
⊢ a = b

tactic: exact (cancel_mono _).1 w
state_before: case right_cancellation
C : Type u
inst✝¹ : Category C
X✝ Y✝ Z✝¹ X Y Z✝ : C
f : X ⟶ Y
g : Y ⟶ Z✝
inst✝ : Mono (f ≫ g)
Z : C
a b : Z ⟶ X
w : a ≫ f ≫ g = b ≫ f ≫ g
⊢ a = b
Theorem: CategoryTheory.SimplicialObject.δ_comp_σ_of_gt
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

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

tactic: simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_σ_of_gt H]
state_before: C : Type u
inst✝ : Category C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : ↑Fin.castSucc j < i
⊢ X.map (SimplexCategory.σ (↑Fin.castSucc j)).op ≫ X.map (SimplexCategory.δ (Fin.succ i)).op =
    X.map (SimplexCategory.δ i).op ≫ X.map (SimplexCategory.σ j).op
Theorem: Cycle.Chain.nil
File: Mathlib/Data/List/Cycle.lean

tactic: trivial
state_before: α : Type u_1
r : α → α → Prop
⊢ Chain r Cycle.nil
Theorem: List.foldrM_reverse
File: Std/Data/List/Init/Lemmas.lean

tactic: simp
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝ : Monad m
l : List α
f : α → β → m β
b : β
⊢ List.foldlM (fun y x => f x y) b (reverse (reverse l)) = List.foldlM (fun x y => f y x) b l
Theorem: MonoidHom.submonoidMap_surjective
File: Mathlib/GroupTheory/Submonoid/Operations.lean

tactic: rintro ⟨_, x, hx, rfl⟩
state_before: M : Type u_1
N : Type u_2
P : Type ?u.149443
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type ?u.149464
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type ?u.149488
mc : MonoidHomClass F M N
f : M →* N
M' : Submonoid M
⊢ Function.Surjective ↑(submonoidMap f M')

tactic: exact ⟨⟨x, hx⟩, rfl⟩
state_before: case mk.intro.intro
M : Type u_1
N : Type u_2
P : Type ?u.149443
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type ?u.149464
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type ?u.149488
mc : MonoidHomClass F M N
f : M →* N
M' : Submonoid M
x : M
hx : x ∈ ↑M'
⊢ ∃ a, ↑(submonoidMap f M') a = { val := ↑f x, property := (_ : ∃ a, a ∈ ↑M' ∧ ↑f a = ↑f x) }
Theorem: FreeRing.coe_neg
File: Mathlib/RingTheory/FreeCommRing.lean

tactic: rw [castFreeCommRing, map_neg]
state_before: α : Type u
x : FreeRing α
⊢ ↑(-x) = -↑x
Theorem: AddMonoidHom.toIntLinearMap_injective
File: Mathlib/Algebra/Module/LinearMap.lean

tactic: intro f g h
state_before: R : Type ?u.355190
R₁ : Type ?u.355193
R₂ : Type ?u.355196
R₃ : Type ?u.355199
k : Type ?u.355202
S : Type ?u.355205
S₃ : Type ?u.355208
T : Type ?u.355211
M : Type u_1
M₁ : Type ?u.355217
M₂ : Type u_2
M₃ : Type ?u.355223
N₁ : Type ?u.355226
N₂ : Type ?u.355229
N₃ : Type ?u.355232
ι : Type ?u.355235
inst✝¹ : AddCommGroup M
inst✝ : AddCommGroup M₂
⊢ Injective toIntLinearMap

tactic: ext x
state_before: R : Type ?u.355190
R₁ : Type ?u.355193
R₂ : Type ?u.355196
R₃ : Type ?u.355199
k : Type ?u.355202
S : Type ?u.355205
S₃ : Type ?u.355208
T : Type ?u.355211
M : Type u_1
M₁ : Type ?u.355217
M₂ : Type u_2
M₃ : Type ?u.355223
N₁ : Type ?u.355226
N₂ : Type ?u.355229
N₃ : Type ?u.355232
ι : Type ?u.355235
inst✝¹ : AddCommGroup M
inst✝ : AddCommGroup M₂
f g : M →+ M₂
h : toIntLinearMap f = toIntLinearMap g
⊢ f = g

tactic: exact LinearMap.congr_fun h x
state_before: case h
R : Type ?u.355190
R₁ : Type ?u.355193
R₂ : Type ?u.355196
R₃ : Type ?u.355199
k : Type ?u.355202
S : Type ?u.355205
S₃ : Type ?u.355208
T : Type ?u.355211
M : Type u_1
M₁ : Type ?u.355217
M₂ : Type u_2
M₃ : Type ?u.355223
N₁ : Type ?u.355226
N₂ : Type ?u.355229
N₃ : Type ?u.355232
ι : Type ?u.355235
inst✝¹ : AddCommGroup M
inst✝ : AddCommGroup M₂
f g : M →+ M₂
h : toIntLinearMap f = toIntLinearMap g
x : M
⊢ ↑f x = ↑g x
Theorem: Finset.compl_filter
File: Mathlib/Data/Fintype/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.13578
γ : Type ?u.13581
inst✝³ : Fintype α
s t : Finset α
inst✝² : DecidableEq α
a : α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : (x : α) → Decidable ¬p x
⊢ ∀ (a : α), a ∈ filter p univᶜ ↔ a ∈ filter (fun x => ¬p x) univ
Theorem: List.map₂Left_eq_zipWith
File: Mathlib/Data/List/Basic.lean

tactic: simp
state_before: ι : Type ?u.466133
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → Option β → γ
as : List α
x✝ : length [] ≤ length []
⊢ map₂Left f [] [] = zipWith (fun a b => f a (some b)) [] []

tactic: simp
state_before: ι : Type ?u.466133
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → Option β → γ
as : List α
head✝ : β
tail✝ : List β
x✝ : length [] ≤ length (head✝ :: tail✝)
⊢ map₂Left f [] (head✝ :: tail✝) = zipWith (fun a b => f a (some b)) [] (head✝ :: tail✝)

tactic: simp at h
state_before: ι : Type ?u.466133
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → Option β → γ
as✝ : List α
a : α
as : List α
h : length (a :: as) ≤ length []
⊢ map₂Left f (a :: as) [] = zipWith (fun a b => f a (some b)) (a :: as) []

tactic: simp [Nat.succ_le_succ_iff] at h
state_before: ι : Type ?u.466133
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → Option β → γ
as✝ : List α
a : α
as : List α
b : β
bs : List β
h : length (a :: as) ≤ length (b :: bs)
⊢ map₂Left f (a :: as) (b :: bs) = zipWith (fun a b => f a (some b)) (a :: as) (b :: bs)

tactic: simp [h, map₂Left_eq_zipWith]
state_before: ι : Type ?u.466133
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → Option β → γ
as✝ : List α
a : α
as : List α
b : β
bs : List β
h : length as ≤ length bs
⊢ map₂Left f (a :: as) (b :: bs) = zipWith (fun a b => f a (some b)) (a :: as) (b :: bs)
Theorem: le_compl_iff_disjoint_right
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [← himp_bot, le_himp_iff, disjoint_iff_inf_le]
state_before: ι : Type ?u.156709
α : Type u_1
β : Type ?u.156715
inst✝ : HeytingAlgebra α
a b c : α
⊢ a ≤ bᶜ ↔ Disjoint a b
Theorem: Function.minimalPeriod_eq_minimalPeriod_iff
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: simp_rw [isPeriodicPt_iff_minimalPeriod_dvd, dvd_right_iff_eq]
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y✝ : α
m n : ℕ
g : β → β
y : β
⊢ minimalPeriod f x = minimalPeriod g y ↔ ∀ (n : ℕ), IsPeriodicPt f n x ↔ IsPeriodicPt g n y
Theorem: Turing.TM2to1.addBottom_head_fst
File: Mathlib/Computability/TuringMachine.lean

tactic: rw [addBottom, ListBlank.head_cons]
state_before: K : Type u_1
inst✝² : DecidableEq K
Γ : K → Type u_2
Λ : Type ?u.605156
inst✝¹ : Inhabited Λ
σ : Type ?u.605162
inst✝ : Inhabited σ
L : ListBlank ((k : K) → Option (Γ k))
⊢ (ListBlank.head (addBottom L)).fst = true
Theorem: stronglyMeasurable_derivWithin_Ioi
File: Mathlib/Analysis/Calculus/FDerivMeasurable.lean

tactic: borelize F
state_before: F : Type u_1
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
f : ℝ → F
K : Set F
inst✝¹ : CompleteSpace F
inst✝ : SecondCountableTopology F
⊢ StronglyMeasurable fun x => derivWithin f (Ioi x) x

tactic: exact (measurable_derivWithin_Ioi f).stronglyMeasurable
state_before: F : Type u_1
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
f : ℝ → F
K : Set F
inst✝¹ : CompleteSpace F
inst✝ : SecondCountableTopology F
this✝¹ : MeasurableSpace F := borel F
this✝ : BorelSpace F
⊢ StronglyMeasurable fun x => derivWithin f (Ioi x) x
Theorem: Finset.prod_le_one'
File: Mathlib/Algebra/BigOperators/Order.lean

tactic: rw [prod_const_one]
state_before: ι : Type u_1
α : Type ?u.18790
β : Type ?u.18793
M : Type ?u.18796
N : Type u_2
G : Type ?u.18802
k : Type ?u.18805
R : Type ?u.18808
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f g : ι → N
s t : Finset ι
h : ∀ (i : ι), i ∈ s → f i ≤ 1
⊢ ∏ i in s, 1 = 1
Theorem: toZ_neg
File: Mathlib/Order/SuccPred/LinearLocallyFinite.lean

tactic: refine' lt_of_le_of_ne _ _
state_before: ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i : ι
hi : i < i0
⊢ toZ i0 i < 0

tactic: rw [toZ_of_lt hi, neg_nonpos]
state_before: case refine'_1
ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i : ι
hi : i < i0
⊢ toZ i0 i ≤ 0

tactic: exact Nat.cast_nonneg _
state_before: case refine'_1
ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i : ι
hi : i < i0
⊢ 0 ≤ ↑(Nat.find (_ : ∃ n, (pred^[n]) i0 = i))

tactic: by_contra h
state_before: case refine'_2
ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i : ι
hi : i < i0
⊢ toZ i0 i ≠ 0

tactic: have h_eq := iterate_pred_toZ i hi
state_before: case refine'_2
ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i : ι
hi : i < i0
h : toZ i0 i = 0
⊢ False

tactic: rw [← h_eq, h] at hi
state_before: case refine'_2
ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i : ι
hi : i < i0
h : toZ i0 i = 0
h_eq : (pred^[Int.toNat (-toZ i0 i)]) i0 = i
⊢ False

tactic: simp only [neg_zero, Int.toNat_zero, Function.iterate_zero, id.def, lt_self_iff_false] at hi
state_before: case refine'_2
ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i : ι
hi : (pred^[Int.toNat (-0)]) i0 < i0
h : toZ i0 i = 0
h_eq : (pred^[Int.toNat (-toZ i0 i)]) i0 = i
⊢ False
Theorem: Bool.xor_comm
File: Mathlib/Data/Bool/Basic.lean

tactic: decide
state_before: ⊢ ∀ (a b : Bool), xor a b = xor b a
Theorem: Real.geom_mean_le_arith_mean4_weighted
File: Mathlib/Analysis/MeanInequalities.lean

tactic: assumption
state_before: ι : Type u
s : Finset ι
w₁ w₂ w₃ w₄ p₁ p₂ p₃ p₄ : ℝ
hw₁ : 0 ≤ w₁
hw₂ : 0 ≤ w₂
hw₃ : 0 ≤ w₃
hw₄ : 0 ≤ w₄
hp₁ : 0 ≤ p₁
hp₂ : 0 ≤ p₂
hp₃ : 0 ≤ p₃
hp₄ : 0 ≤ p₄
hw : w₁ + w₂ + w₃ + w₄ = 1
⊢ ↑({ val := w₁, property := hw₁ } + { val := w₂, property := hw₂ } + { val := w₃, property := hw₃ } +
        { val := w₄, property := hw₄ }) =
    ↑1
Theorem: MeasureTheory.integrable_map_measure
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp_rw [← memℒp_one_iff_integrable]
state_before: α : Type u_3
β : Type u_2
γ : Type ?u.857469
δ : Type u_1
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → δ
g : δ → β
hg : AEStronglyMeasurable g (Measure.map f μ)
hf : AEMeasurable f
⊢ Integrable g ↔ Integrable (g ∘ f)

tactic: exact memℒp_map_measure_iff hg hf
state_before: α : Type u_3
β : Type u_2
γ : Type ?u.857469
δ : Type u_1
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → δ
g : δ → β
hg : AEStronglyMeasurable g (Measure.map f μ)
hf : AEMeasurable f
⊢ Memℒp g 1 ↔ Memℒp (g ∘ f) 1
Theorem: differentiable_const_sub_iff
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simp [sub_eq_add_neg]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.569259
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.569354
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
c : F
⊢ (Differentiable 𝕜 fun y => c - f y) ↔ Differentiable 𝕜 f
Theorem: eq_of_smul_eq_smul_of_neg_of_le
File: Mathlib/Algebra/Order/Module.lean

tactic: rw [← neg_neg c, neg_smul, neg_smul (-c), neg_inj] at hab
state_before: k : Type u_2
M : Type u_1
N : Type ?u.17203
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup M
inst✝¹ : Module k M
inst✝ : OrderedSMul k M
a b : M
c : k
hab : c • a = c • b
hc : c < 0
h : a ≤ b
⊢ a = b

tactic: exact eq_of_smul_eq_smul_of_pos_of_le hab (neg_pos_of_neg hc) h
state_before: k : Type u_2
M : Type u_1
N : Type ?u.17203
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup M
inst✝¹ : Module k M
inst✝ : OrderedSMul k M
a b : M
c : k
hab : -c • a = -c • b
hc : c < 0
h : a ≤ b
⊢ a = b
Theorem: Monotone.isBoundedUnder_le_comp
File: Mathlib/Order/LiminfLimsup.lean

tactic: refine' ⟨_, fun h => h.isBoundedUnder (α := β) hg⟩
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
ι : Type ?u.197009
inst✝³ : Nonempty β
inst✝² : LinearOrder β
inst✝¹ : Preorder γ
inst✝ : NoMaxOrder γ
g : β → γ
f : α → β
l : Filter α
hg : Monotone g
hg' : Tendsto g atTop atTop
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) l (g ∘ f) ↔ IsBoundedUnder (fun x x_1 => x ≤ x_1) l f

tactic: rintro ⟨c, hc⟩
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
ι : Type ?u.197009
inst✝³ : Nonempty β
inst✝² : LinearOrder β
inst✝¹ : Preorder γ
inst✝ : NoMaxOrder γ
g : β → γ
f : α → β
l : Filter α
hg : Monotone g
hg' : Tendsto g atTop atTop
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) l (g ∘ f) → IsBoundedUnder (fun x x_1 => x ≤ x_1) l f

tactic: rw [eventually_map] at hc
state_before: case intro
α : Type u_3
β : Type u_1
γ : Type u_2
ι : Type ?u.197009
inst✝³ : Nonempty β
inst✝² : LinearOrder β
inst✝¹ : Preorder γ
inst✝ : NoMaxOrder γ
g : β → γ
f : α → β
l : Filter α
hg : Monotone g
hg' : Tendsto g atTop atTop
c : γ
hc : ∀ᶠ (x : γ) in map (g ∘ f) l, (fun x x_1 => x ≤ x_1) x c
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) l f

tactic: obtain ⟨b, hb⟩ : ∃ b, ∀ a ≥ b, c < g a := eventually_atTop.1 (hg'.eventually_gt_atTop c)
state_before: case intro
α : Type u_3
β : Type u_1
γ : Type u_2
ι : Type ?u.197009
inst✝³ : Nonempty β
inst✝² : LinearOrder β
inst✝¹ : Preorder γ
inst✝ : NoMaxOrder γ
g : β → γ
f : α → β
l : Filter α
hg : Monotone g
hg' : Tendsto g atTop atTop
c : γ
hc : ∀ᶠ (a : α) in l, (fun x x_1 => x ≤ x_1) ((g ∘ f) a) c
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) l f

tactic: exact ⟨b, hc.mono fun x hx => not_lt.1 fun h => (hb _ h.le).not_le hx⟩
state_before: case intro.intro
α : Type u_3
β : Type u_1
γ : Type u_2
ι : Type ?u.197009
inst✝³ : Nonempty β
inst✝² : LinearOrder β
inst✝¹ : Preorder γ
inst✝ : NoMaxOrder γ
g : β → γ
f : α → β
l : Filter α
hg : Monotone g
hg' : Tendsto g atTop atTop
c : γ
hc : ∀ᶠ (a : α) in l, (fun x x_1 => x ≤ x_1) ((g ∘ f) a) c
b : β
hb : ∀ (a : β), a ≥ b → c < g a
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) l f
Theorem: Set.univ_pi_ite
File: Mathlib/Data/Set/Prod.lean

tactic: ext
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.166768
s✝ s₁ s₂ : Set ι
t✝ t₁ t₂ : (i : ι) → Set (α i)
i : ι
s : Set ι
inst✝ : DecidablePred fun x => x ∈ s
t : (i : ι) → Set (α i)
⊢ (pi univ fun i => if i ∈ s then t i else univ) = pi s t

tactic: simp_rw [mem_univ_pi]
state_before: case h
ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.166768
s✝ s₁ s₂ : Set ι
t✝ t₁ t₂ : (i : ι) → Set (α i)
i : ι
s : Set ι
inst✝ : DecidablePred fun x => x ∈ s
t : (i : ι) → Set (α i)
x✝ : (i : ι) → α i
⊢ (x✝ ∈ pi univ fun i => if i ∈ s then t i else univ) ↔ x✝ ∈ pi s t

tactic: refine' forall_congr' fun i => _
state_before: case h
ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.166768
s✝ s₁ s₂ : Set ι
t✝ t₁ t₂ : (i : ι) → Set (α i)
i : ι
s : Set ι
inst✝ : DecidablePred fun x => x ∈ s
t : (i : ι) → Set (α i)
x✝ : (i : ι) → α i
⊢ (∀ (i : ι), x✝ i ∈ if i ∈ s then t i else univ) ↔ x✝ ∈ pi s t

tactic: split_ifs with h <;> simp [h]
state_before: case h
ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.166768
s✝ s₁ s₂ : Set ι
t✝ t₁ t₂ : (i : ι) → Set (α i)
i✝ : ι
s : Set ι
inst✝ : DecidablePred fun x => x ∈ s
t : (i : ι) → Set (α i)
x✝ : (i : ι) → α i
i : ι
⊢ (x✝ i ∈ if i ∈ s then t i else univ) ↔ i ∈ s → x✝ i ∈ t i
Theorem: PSet.mem_sUnion
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: rwa [eta] at this
state_before: α : Type u
A : α → PSet
y : PSet
x✝ : y ∈ ⋃₀ mk α A
a : Type (mk α A)
c : Type (Func (mk α A) a)
e : Equiv y (Func (A a) c)
this : Func (A a) c ∈ mk (Type (A a)) (Func (A a))
⊢ Func (A a) c ∈ A (?m.27126 α A y x✝ a c e this)

tactic: rw [← eta (A a)] at e
state_before: α : Type u
A : α → PSet
y : PSet
x✝ : ∃ z, z ∈ mk α A ∧ y ∈ z
β : Type u
B : β → PSet
a : Type (mk α A)
e : Equiv (mk β B) (A a)
b : Type (mk β B)
yb : Equiv y (Func (mk β B) b)
⊢ y ∈ ⋃₀ mk α A

tactic: exact
  let ⟨βt, _⟩ := e
  let ⟨c, bc⟩ := βt b
  ⟨⟨a, c⟩, yb.trans bc⟩
state_before: α : Type u
A : α → PSet
y : PSet
x✝ : ∃ z, z ∈ mk α A ∧ y ∈ z
β : Type u
B : β → PSet
a : Type (mk α A)
e : Equiv (mk β B) (mk (Type (A a)) (Func (A a)))
b : Type (mk β B)
yb : Equiv y (Func (mk β B) b)
⊢ y ∈ ⋃₀ mk α A
Theorem: Int.negSucc_coe'
File: Std/Data/Int/Lemmas.lean

tactic: rw [Int.sub_eq_add_neg, ← Int.neg_add]
state_before: n : Nat
⊢ -[n+1] = -↑n - 1

tactic: rfl
state_before: n : Nat
⊢ -[n+1] = -(↑n + 1)
Theorem: KuratowskiEmbedding.embeddingOfSubset_dist_le
File: Mathlib/Topology/MetricSpace/Kuratowski.lean

tactic: refine' lp.norm_le_of_forall_le dist_nonneg fun n => _
state_before: α : Type u
β : Type v
γ : Type w
f g : { x // x ∈ lp (fun n => ℝ) ⊤ }
n : ℕ
C : ℝ
inst✝ : MetricSpace α
x : ℕ → α
a✝ b✝ a b : α
⊢ dist (embeddingOfSubset x a) (embeddingOfSubset x b) ≤ dist a b

tactic: simp only [lp.coeFn_sub, Pi.sub_apply, embeddingOfSubset_coe, Real.dist_eq]
state_before: α : Type u
β : Type v
γ : Type w
f g : { x // x ∈ lp (fun n => ℝ) ⊤ }
n✝ : ℕ
C : ℝ
inst✝ : MetricSpace α
x : ℕ → α
a✝ b✝ a b : α
n : ℕ
⊢ ‖↑(embeddingOfSubset x a - embeddingOfSubset x b) n‖ ≤ dist a b

tactic: convert abs_dist_sub_le a b (x n) using 2
state_before: α : Type u
β : Type v
γ : Type w
f g : { x // x ∈ lp (fun n => ℝ) ⊤ }
n✝ : ℕ
C : ℝ
inst✝ : MetricSpace α
x : ℕ → α
a✝ b✝ a b : α
n : ℕ
⊢ ‖dist a (x n) - dist (x 0) (x n) - (dist b (x n) - dist (x 0) (x n))‖ ≤ dist a b

tactic: ring
state_before: case h.e'_3.h.e'_1
α : Type u
β : Type v
γ : Type w
f g : { x // x ∈ lp (fun n => ℝ) ⊤ }
n✝ : ℕ
C : ℝ
inst✝ : MetricSpace α
x : ℕ → α
a✝ b✝ a b : α
n : ℕ
⊢ dist a (x n) - dist (x 0) (x n) - (dist b (x n) - dist (x 0) (x n)) = dist a (x n) - dist b (x n)
Theorem: ComputablePred.computable_iff
File: Mathlib/Computability/Halting.lean

tactic: rintro ⟨f, h, rfl⟩
state_before: α : Type u_1
σ : Type ?u.282635
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
p : α → Prop
⊢ (∃ f, Computable f ∧ p = fun a => f a = true) → ComputablePred p

tactic: exact ⟨by infer_instance, by simpa using h⟩
state_before: case intro.intro
α : Type u_1
σ : Type ?u.282635
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
f : α → Bool
h : Computable f
⊢ ComputablePred fun a => f a = true

tactic: infer_instance
state_before: α : Type u_1
σ : Type ?u.282635
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
f : α → Bool
h : Computable f
⊢ DecidablePred fun a => f a = true

tactic: simpa using h
state_before: α : Type u_1
σ : Type ?u.282635
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
f : α → Bool
h : Computable f
⊢ Computable fun a => decide ((fun a => f a = true) a)
Theorem: Real.continuousAt_log_iff
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: refine' ⟨_, continuousAt_log⟩
state_before: x y : ℝ
⊢ ContinuousAt log x ↔ x ≠ 0

tactic: rintro h rfl
state_before: x y : ℝ
⊢ ContinuousAt log x → x ≠ 0

tactic: exact not_tendsto_nhds_of_tendsto_atBot tendsto_log_nhdsWithin_zero _
  (h.tendsto.mono_left inf_le_left)
state_before: y : ℝ
h : ContinuousAt log 0
⊢ False
Theorem: LinearMap.ker_eq_bot'
File: Mathlib/LinearAlgebra/Basic.lean

tactic: simpa [disjoint_iff_inf_le] using @disjoint_ker _ _ _ _ _ _ _ _ _ _ _ _ _ f ⊤
state_before: R : Type u_2
R₁ : Type ?u.1204225
R₂ : Type u_3
R₃ : Type ?u.1204231
R₄ : Type ?u.1204234
S : Type ?u.1204237
K : Type ?u.1204240
K₂ : Type ?u.1204243
M : Type u_1
M' : Type ?u.1204249
M₁ : Type ?u.1204252
M₂ : Type u_4
M₃ : Type ?u.1204258
M₄ : Type ?u.1204261
N : Type ?u.1204264
N₂ : Type ?u.1204267
ι : Type ?u.1204270
V : Type ?u.1204273
V₂ : Type ?u.1204276
inst✝¹⁰ : Semiring R
inst✝⁹ : Semiring R₂
inst✝⁸ : Semiring R₃
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁴ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝³ : Module R M
inst✝² : Module R₂ M₂
inst✝¹ : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_5
sc : SemilinearMapClass F τ₁₂ M M₂
f : F
⊢ ker f = ⊥ ↔ ∀ (m : M), ↑f m = 0 → m = 0
Theorem: MvPolynomial.weightedHomogeneousComponent_zero
File: Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean

tactic: ext1 d
state_before: R : Type u_2
M : Type u_1
inst✝² : CommSemiring R
σ : Type u_3
inst✝¹ : CanonicallyOrderedAddMonoid M
w : σ → M
φ : MvPolynomial σ R
inst✝ : NoZeroSMulDivisors ℕ M
hw : ∀ (i : σ), w i ≠ 0
⊢ ↑(weightedHomogeneousComponent w 0) φ = ↑C (coeff 0 φ)

tactic: rcases Classical.em (d = 0) with (rfl | hd)
state_before: case a
R : Type u_2
M : Type u_1
inst✝² : CommSemiring R
σ : Type u_3
inst✝¹ : CanonicallyOrderedAddMonoid M
w : σ → M
φ : MvPolynomial σ R
inst✝ : NoZeroSMulDivisors ℕ M
hw : ∀ (i : σ), w i ≠ 0
d : σ →₀ ℕ
⊢ coeff d (↑(weightedHomogeneousComponent w 0) φ) = coeff d (↑C (coeff 0 φ))

tactic: simp only [coeff_weightedHomogeneousComponent, if_pos, map_zero, coeff_zero_C]
state_before: case a.inl
R : Type u_2
M : Type u_1
inst✝² : CommSemiring R
σ : Type u_3
inst✝¹ : CanonicallyOrderedAddMonoid M
w : σ → M
φ : MvPolynomial σ R
inst✝ : NoZeroSMulDivisors ℕ M
hw : ∀ (i : σ), w i ≠ 0
⊢ coeff 0 (↑(weightedHomogeneousComponent w 0) φ) = coeff 0 (↑C (coeff 0 φ))

tactic: rw [coeff_weightedHomogeneousComponent, if_neg, coeff_C, if_neg (Ne.symm hd)]
state_before: case a.inr
R : Type u_2
M : Type u_1
inst✝² : CommSemiring R
σ : Type u_3
inst✝¹ : CanonicallyOrderedAddMonoid M
w : σ → M
φ : MvPolynomial σ R
inst✝ : NoZeroSMulDivisors ℕ M
hw : ∀ (i : σ), w i ≠ 0
d : σ →₀ ℕ
hd : ¬d = 0
⊢ coeff d (↑(weightedHomogeneousComponent w 0) φ) = coeff d (↑C (coeff 0 φ))

tactic: simp only [weightedDegree', LinearMap.toAddMonoidHom_coe, Finsupp.total_apply, Finsupp.sum,
  sum_eq_zero_iff, Finsupp.mem_support_iff, Ne.def, smul_eq_zero, not_forall, not_or,
  and_self_left, exists_prop]
state_before: case a.inr.hnc
R : Type u_2
M : Type u_1
inst✝² : CommSemiring R
σ : Type u_3
inst✝¹ : CanonicallyOrderedAddMonoid M
w : σ → M
φ : MvPolynomial σ R
inst✝ : NoZeroSMulDivisors ℕ M
hw : ∀ (i : σ), w i ≠ 0
d : σ →₀ ℕ
hd : ¬d = 0
⊢ ¬↑(weightedDegree' w) d = 0

tactic: simp only [FunLike.ext_iff, Finsupp.coe_zero, Pi.zero_apply, not_forall] at hd
state_before: case a.inr.hnc
R : Type u_2
M : Type u_1
inst✝² : CommSemiring R
σ : Type u_3
inst✝¹ : CanonicallyOrderedAddMonoid M
w : σ → M
φ : MvPolynomial σ R
inst✝ : NoZeroSMulDivisors ℕ M
hw : ∀ (i : σ), w i ≠ 0
d : σ →₀ ℕ
hd : ¬d = 0
⊢ ∃ x, ¬↑d x = 0 ∧ ¬w x = 0

tactic: obtain ⟨i, hi⟩ := hd
state_before: case a.inr.hnc
R : Type u_2
M : Type u_1
inst✝² : CommSemiring R
σ : Type u_3
inst✝¹ : CanonicallyOrderedAddMonoid M
w : σ → M
φ : MvPolynomial σ R
inst✝ : NoZeroSMulDivisors ℕ M
hw : ∀ (i : σ), w i ≠ 0
d : σ →₀ ℕ
hd : ∃ x, ¬↑d x = 0
⊢ ∃ x, ¬↑d x = 0 ∧ ¬w x = 0

tactic: exact ⟨i, hi, hw i⟩
state_before: case a.inr.hnc.intro
R : Type u_2
M : Type u_1
inst✝² : CommSemiring R
σ : Type u_3
inst✝¹ : CanonicallyOrderedAddMonoid M
w : σ → M
φ : MvPolynomial σ R
inst✝ : NoZeroSMulDivisors ℕ M
hw : ∀ (i : σ), w i ≠ 0
d : σ →₀ ℕ
i : σ
hi : ¬↑d i = 0
⊢ ∃ x, ¬↑d x = 0 ∧ ¬w x = 0