tasksource/leandojo huggingface dataset:
Theorem: Finset.prod_ite_irrel
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: split_ifs with h <;> rfl
state_before: ι : Type ?u.417321
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
p : Prop
inst✝ : Decidable p
s : Finset α
f g : α → β
⊢ (∏ x in s, if p then f x else g x) = if p then ∏ x in s, f x else ∏ x in s, g x
Theorem: toIcoDiv_sub_eq_toIcoDiv_add
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: apply toIcoDiv_eq_of_sub_zsmul_mem_Ico
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c✝ : α
n : ℤ
a b c : α
⊢ toIcoDiv hp a (b - c) = toIcoDiv hp (a + c) b

tactic: rw [← sub_right_comm, Set.sub_mem_Ico_iff_left, add_right_comm]
state_before: case h
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c✝ : α
n : ℤ
a b c : α
⊢ b - c - toIcoDiv hp (a + c) b • p ∈ Set.Ico a (a + p)

tactic: exact sub_toIcoDiv_zsmul_mem_Ico hp (a + c) b
state_before: case h
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c✝ : α
n : ℤ
a b c : α
⊢ b - toIcoDiv hp (a + c) b • p ∈ Set.Ico (a + c) (a + c + p)
Theorem: Finpartition.exists_mem
File: Mathlib/Order/Partition/Finpartition.lean

tactic: simp_rw [← P.supParts] at ha
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
a : α
ha : a ∈ s
⊢ ∃ t, t ∈ P.parts ∧ a ∈ t

tactic: exact mem_sup.1 ha
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
a : α
ha : a ∈ sup P.parts id
⊢ ∃ t, t ∈ P.parts ∧ a ∈ t
Theorem: sup_idem
File: Mathlib/Order/Lattice.lean

tactic: simp
state_before: α : Type u
β : Type v
inst✝ : SemilatticeSup α
a b c d : α
⊢ a ⊔ a = a
Theorem: Bool.or_eq_false_eq_eq_false_and_eq_false
File: Mathlib/Init/Data/Bool/Lemmas.lean

tactic: cases a <;> cases b <;> simp
state_before: a b : Bool
⊢ ((a || b) = false) = (a = false ∧ b = false)
Theorem: List.nodupKeys_cons
File: Mathlib/Data/List/Sigma.lean

tactic: simp [keys, NodupKeys]
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
s : Sigma β
l : List (Sigma β)
⊢ NodupKeys (s :: l) ↔ ¬s.fst ∈ keys l ∧ NodupKeys l
Theorem: InfHom.cancel_left
File: Mathlib/Order/Hom/Lattice.lean

tactic: rw [← InfHom.comp_apply, h, InfHom.comp_apply]
state_before: F : Type ?u.80850
ι : Type ?u.80853
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.80865
inst✝³ : Inf α
inst✝² : Inf β
inst✝¹ : Inf γ
inst✝ : Inf δ
g : InfHom β γ
f₁ f₂ : InfHom α β
hg : Injective ↑g
h : comp g f₁ = comp g f₂
a : α
⊢ ↑g (↑f₁ a) = ↑g (↑f₂ a)
Theorem: CategoryTheory.GrothendieckTopology.arrow_trans
File: Mathlib/CategoryTheory/Sites/Grothendieck.lean

tactic: intro k
state_before: C : Type u
inst✝ : Category C
X Y : C
S✝ R✝ : Sieve X
J : GrothendieckTopology C
f : Y ⟶ X
S R : Sieve X
h : Covers J S f
⊢ (∀ {Z : C} (g : Z ⟶ X), S.arrows g → Covers J R g) → Covers J R f

tactic: apply J.transitive h
state_before: C : Type u
inst✝ : Category C
X Y : C
S✝ R✝ : Sieve X
J : GrothendieckTopology C
f : Y ⟶ X
S R : Sieve X
h : Covers J S f
k : ∀ {Z : C} (g : Z ⟶ X), S.arrows g → Covers J R g
⊢ Covers J R f

tactic: intro Z g hg
state_before: case h
C : Type u
inst✝ : Category C
X Y : C
S✝ R✝ : Sieve X
J : GrothendieckTopology C
f : Y ⟶ X
S R : Sieve X
h : Covers J S f
k : ∀ {Z : C} (g : Z ⟶ X), S.arrows g → Covers J R g
⊢ ∀ ⦃Y_1 : C⦄ ⦃f_1 : Y_1 ⟶ Y⦄, (Sieve.pullback f S).arrows f_1 → Sieve.pullback f_1 (Sieve.pullback f R) ∈ sieves J Y_1

tactic: rw [← Sieve.pullback_comp]
state_before: case h
C : Type u
inst✝ : Category C
X Y : C
S✝ R✝ : Sieve X
J : GrothendieckTopology C
f : Y ⟶ X
S R : Sieve X
h : Covers J S f
k : ∀ {Z : C} (g : Z ⟶ X), S.arrows g → Covers J R g
Z : C
g : Z ⟶ Y
hg : (Sieve.pullback f S).arrows g
⊢ Sieve.pullback g (Sieve.pullback f R) ∈ sieves J Z

tactic: apply k (g ≫ f) hg
state_before: case h
C : Type u
inst✝ : Category C
X Y : C
S✝ R✝ : Sieve X
J : GrothendieckTopology C
f : Y ⟶ X
S R : Sieve X
h : Covers J S f
k : ∀ {Z : C} (g : Z ⟶ X), S.arrows g → Covers J R g
Z : C
g : Z ⟶ Y
hg : (Sieve.pullback f S).arrows g
⊢ Sieve.pullback (g ≫ f) R ∈ sieves J Z
Theorem: PartENat.le_of_lt_add_one
File: Mathlib/Data/Nat/PartENat.lean

tactic: induction' y using PartENat.casesOn with n
state_before: x y : PartENat
h : x < y + 1
⊢ x ≤ y

tactic: rcases ne_top_iff.mp (ne_top_of_lt h) with ⟨m, rfl⟩
state_before: case a
x y : PartENat
h✝ : x < y + 1
n : ℕ
h : x < ↑n + 1
⊢ x ≤ ↑n

tactic: norm_cast
state_before: case a.intro
y : PartENat
n m : ℕ
h✝ : ↑m < y + 1
h : ↑m < ↑n + 1
⊢ ↑m ≤ ↑n

tactic: apply Nat.le_of_lt_succ
state_before: case a.intro
y : PartENat
n m : ℕ
h✝ : ↑m < y + 1
h : ↑m < ↑n + 1
⊢ m ≤ n

tactic: norm_cast at h
state_before: case a.intro.a
y : PartENat
n m : ℕ
h✝ : ↑m < y + 1
h : ↑m < ↑n + 1
⊢ m < Nat.succ n

tactic: apply le_top
state_before: case a
x y : PartENat
h✝ : x < y + 1
h : x < ⊤ + 1
⊢ x ≤ ⊤
Theorem: NormedField.continuousAt_inv
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: simpa [(zero_lt_one' ℤ).not_le] using @continuousAt_zpow _ _ (-1) x
state_before: α : Type ?u.67516
β : Type ?u.67519
ι : Type ?u.67522
𝕜 : Type u_1
inst✝ : NontriviallyNormedField 𝕜
x : 𝕜
⊢ ContinuousAt Inv.inv x ↔ x ≠ 0
Theorem: BoxIntegral.Prepartition.iUnion_disjUnion
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: simp [disjUnion, Prepartition.iUnion, iUnion_or, iUnion_union_distrib]
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
h : Disjoint (Prepartition.iUnion π₁) (Prepartition.iUnion π₂)
⊢ Prepartition.iUnion (disjUnion π₁ π₂ h) = Prepartition.iUnion π₁ ∪ Prepartition.iUnion π₂
Theorem: WithBot.preimage_coe_Icc
File: Mathlib/Data/Set/Intervals/WithBotTop.lean

tactic: simp [← Ici_inter_Iic]
state_before: α : Type u_1
inst✝ : PartialOrder α
a b : α
⊢ some ⁻¹' Icc ↑a ↑b = Icc a b
Theorem: LowerSet.map_refl
File: Mathlib/Order/UpperLower/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.106343
γ : Type ?u.106346
ι : Sort ?u.106349
κ : ι → Sort ?u.106354
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α ≃o β
s t : LowerSet α
a : α
b : β
⊢ map (OrderIso.refl α) = OrderIso.refl (LowerSet α)

tactic: simp
state_before: case h.h.a.h
α : Type u_1
β : Type ?u.106343
γ : Type ?u.106346
ι : Sort ?u.106349
κ : ι → Sort ?u.106354
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α ≃o β
s t : LowerSet α
a : α
b : β
x✝¹ : LowerSet α
x✝ : α
⊢ x✝ ∈ ↑(↑(map (OrderIso.refl α)) x✝¹) ↔ x✝ ∈ ↑(↑(OrderIso.refl (LowerSet α)) x✝¹)
Theorem: sInf_image2
File: Mathlib/Order/CompleteLattice.lean

tactic: rw [← image_prod, sInf_image, biInf_prod]
state_before: α : Type u_3
β : Type u_1
β₂ : Type ?u.175983
γ : Type u_2
ι : Sort ?u.175989
ι' : Sort ?u.175992
κ : ι → Sort ?u.175997
κ' : ι' → Sort ?u.176002
inst✝ : CompleteLattice α
f✝ g s✝ t✝ : ι → α
a b : α
f : β → γ → α
s : Set β
t : Set γ
⊢ sInf (image2 f s t) = ⨅ (a : β) (_ : a ∈ s) (b : γ) (_ : b ∈ t), f a b
Theorem: AffineBasis.nonempty
File: Mathlib/LinearAlgebra/AffineSpace/Basis.lean

tactic: simpa only [@range_eq_empty _ _ hι, AffineSubspace.span_empty, bot_ne_top] using b.tot
state_before: ι : Type u_1
ι' : Type ?u.10411
k : Type ?u.10414
V : Type ?u.10417
P : Type ?u.10420
inst✝³ : AddCommGroup V
inst✝² : AffineSpace V P
inst✝¹ : Ring k
inst✝ : Module k V
b : AffineBasis ι k P
s : Finset ι
i j : ι
e : ι ≃ ι'
hι : IsEmpty ι
⊢ False
Theorem: NNReal.exists_le_hasSum_of_le
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: refine hasSum_le (fun b => ?_) ENNReal.summable.hasSum (ENNReal.hasSum_coe.2 hfr)
state_before: α : Type ?u.310040
β : Type u_1
γ : Type ?u.310046
f g : β → ℝ≥0
r : ℝ≥0
hgf : ∀ (b : β), g b ≤ f b
hfr : HasSum f r
⊢ (∑' (b : β), ↑(g b)) ≤ ↑r

tactic: exact ENNReal.coe_le_coe.2 (hgf _)
state_before: α : Type ?u.310040
β : Type u_1
γ : Type ?u.310046
f g : β → ℝ≥0
r : ℝ≥0
hgf : ∀ (b : β), g b ≤ f b
hfr : HasSum f r
b : β
⊢ ↑(g b) ≤ ↑(f b)
Theorem: CategoryTheory.isSeparating_iff_epi
File: Mathlib/CategoryTheory/Generator.lean

tactic: refine' ⟨fun h A => ⟨fun u v huv => h _ _ fun G hG f => _⟩, fun h X Y f g hh => _⟩
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
𝒢 : Set C
inst✝ : ∀ (A : C), HasCoproduct fun f => ↑f.fst
⊢ IsSeparating 𝒢 ↔ ∀ (A : C), Epi (Sigma.desc Sigma.snd)

tactic: simpa using Sigma.ι (fun f : ΣG : 𝒢, (G : C) ⟶ A => (f.1 : C)) ⟨⟨G, hG⟩, f⟩ ≫= huv
state_before: case refine'_1
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
𝒢 : Set C
inst✝ : ∀ (A : C), HasCoproduct fun f => ↑f.fst
h : IsSeparating 𝒢
A Z✝ : C
u v : A ⟶ Z✝
huv : Sigma.desc Sigma.snd ≫ u = Sigma.desc Sigma.snd ≫ v
G : C
hG : G ∈ 𝒢
f : G ⟶ A
⊢ f ≫ u = f ≫ v

tactic: haveI := h X
state_before: case refine'_2
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
𝒢 : Set C
inst✝ : ∀ (A : C), HasCoproduct fun f => ↑f.fst
h : ∀ (A : C), Epi (Sigma.desc Sigma.snd)
X Y : C
f g : X ⟶ Y
hh : ∀ (G : C), G ∈ 𝒢 → ∀ (h : G ⟶ X), h ≫ f = h ≫ g
⊢ f = g

tactic: refine'
  (cancel_epi (Sigma.desc (@Sigma.snd 𝒢 fun G => (G : C) ⟶ X))).1 (colimit.hom_ext fun j => _)
state_before: case refine'_2
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
𝒢 : Set C
inst✝ : ∀ (A : C), HasCoproduct fun f => ↑f.fst
h : ∀ (A : C), Epi (Sigma.desc Sigma.snd)
X Y : C
f g : X ⟶ Y
hh : ∀ (G : C), G ∈ 𝒢 → ∀ (h : G ⟶ X), h ≫ f = h ≫ g
this : Epi (Sigma.desc Sigma.snd)
⊢ f = g

tactic: simpa using hh j.as.1.1 j.as.1.2 j.as.2
state_before: case refine'_2
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
𝒢 : Set C
inst✝ : ∀ (A : C), HasCoproduct fun f => ↑f.fst
h : ∀ (A : C), Epi (Sigma.desc Sigma.snd)
X Y : C
f g : X ⟶ Y
hh : ∀ (G : C), G ∈ 𝒢 → ∀ (h : G ⟶ X), h ≫ f = h ≫ g
this : Epi (Sigma.desc Sigma.snd)
j : Discrete ((G : ↑𝒢) × (↑G ⟶ X))
⊢ colimit.ι (Discrete.functor fun b => ↑b.fst) j ≫ Sigma.desc Sigma.snd ≫ f =
    colimit.ι (Discrete.functor fun b => ↑b.fst) j ≫ Sigma.desc Sigma.snd ≫ g
Theorem: dvd_pow
File: Mathlib/Algebra/GroupPower/Basic.lean

tactic: rw [pow_succ]
state_before: α : Type ?u.46449
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝¹ : Monoid M
inst✝ : AddMonoid A
x y : M
hxy : x ∣ y
n : ℕ
x✝ : n + 1 ≠ 0
⊢ x ∣ y ^ (n + 1)

tactic: exact hxy.mul_right _
state_before: α : Type ?u.46449
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝¹ : Monoid M
inst✝ : AddMonoid A
x y : M
hxy : x ∣ y
n : ℕ
x✝ : n + 1 ≠ 0
⊢ x ∣ y * y ^ n
Theorem: WType.leftInverse_nat
File: Mathlib/Data/W/Constructions.lean

tactic: rw [toNat, ofNat]
state_before: f : Natβ Natα.zero → WType Natβ
⊢ ofNat (toNat (mk Natα.zero f)) = mk Natα.zero f

tactic: congr
state_before: f : Natβ Natα.zero → WType Natβ
⊢ mk Natα.zero Empty.elim = mk Natα.zero f

tactic: ext x
state_before: case e_f
f : Natβ Natα.zero → WType Natβ
⊢ Empty.elim = f

tactic: cases x
state_before: case e_f.h
f : Natβ Natα.zero → WType Natβ
x : Empty
⊢ Empty.elim x = f x

tactic: simp only [toNat, ofNat, leftInverse_nat (f ()), mk.injEq, heq_eq_eq, true_and]
state_before: f : Natβ Natα.succ → WType Natβ
⊢ ofNat (toNat (mk Natα.succ f)) = mk Natα.succ f

tactic: rfl
state_before: f : Natβ Natα.succ → WType Natβ
⊢ (fun x => f ()) = f
Theorem: upperClosure_sups
File: Mathlib/Data/Set/Sups.lean

tactic: ext a
state_before: α : Type u_1
inst✝ : SemilatticeSup α
s t : Set α
⊢ upperClosure (s ⊻ t) = upperClosure s ⊔ upperClosure t

tactic: simp only [SetLike.mem_coe, mem_upperClosure, Set.mem_sups, exists_and_left, exists_prop,
  UpperSet.coe_sup, Set.mem_inter_iff]
state_before: case a.h
α : Type u_1
inst✝ : SemilatticeSup α
s t : Set α
a : α
⊢ a ∈ ↑(upperClosure (s ⊻ t)) ↔ a ∈ ↑(upperClosure s ⊔ upperClosure t)

tactic: constructor
state_before: case a.h
α : Type u_1
inst✝ : SemilatticeSup α
s t : Set α
a : α
⊢ (∃ a_1, (∃ a, a ∈ s ∧ ∃ b, b ∈ t ∧ a ⊔ b = a_1) ∧ a_1 ≤ a) ↔ (∃ a_1, a_1 ∈ s ∧ a_1 ≤ a) ∧ ∃ a_1, a_1 ∈ t ∧ a_1 ≤ a

tactic: rintro ⟨_, ⟨b, hb, c, hc, rfl⟩, ha⟩
state_before: case a.h.mp
α : Type u_1
inst✝ : SemilatticeSup α
s t : Set α
a : α
⊢ (∃ a_1, (∃ a, a ∈ s ∧ ∃ b, b ∈ t ∧ a ⊔ b = a_1) ∧ a_1 ≤ a) → (∃ a_2, a_2 ∈ s ∧ a_2 ≤ a) ∧ ∃ a_2, a_2 ∈ t ∧ a_2 ≤ a

tactic: exact ⟨⟨b, hb, le_sup_left.trans ha⟩, c, hc, le_sup_right.trans ha⟩
state_before: case a.h.mp.intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝ : SemilatticeSup α
s t : Set α
a b : α
hb : b ∈ s
c : α
hc : c ∈ t
ha : b ⊔ c ≤ a
⊢ (∃ a_1, a_1 ∈ s ∧ a_1 ≤ a) ∧ ∃ a_1, a_1 ∈ t ∧ a_1 ≤ a

tactic: rintro ⟨⟨b, hb, hab⟩, c, hc, hac⟩
state_before: case a.h.mpr
α : Type u_1
inst✝ : SemilatticeSup α
s t : Set α
a : α
⊢ ((∃ a_1, a_1 ∈ s ∧ a_1 ≤ a) ∧ ∃ a_1, a_1 ∈ t ∧ a_1 ≤ a) → ∃ a_2, (∃ a, a ∈ s ∧ ∃ b, b ∈ t ∧ a ⊔ b = a_2) ∧ a_2 ≤ a

tactic: exact ⟨_, ⟨b, hb, c, hc, rfl⟩, sup_le hab hac⟩
state_before: case a.h.mpr.intro.intro.intro.intro.intro
α : Type u_1
inst✝ : SemilatticeSup α
s t : Set α
a b : α
hb : b ∈ s
hab : b ≤ a
c : α
hc : c ∈ t
hac : c ≤ a
⊢ ∃ a_1, (∃ a, a ∈ s ∧ ∃ b, b ∈ t ∧ a ⊔ b = a_1) ∧ a_1 ≤ a
Theorem: List.prefix_iff_eq_append
File: Mathlib/Data/List/Infix.lean

tactic: rintro ⟨r, rfl⟩
state_before: α : Type u_1
β : Type ?u.3114
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
⊢ l₁ <+: l₂ → l₁ ++ drop (length l₁) l₂ = l₂

tactic: rw [drop_left]
state_before: case intro
α : Type u_1
β : Type ?u.3114
l l₁ l₃ : List α
a b : α
m n : ℕ
r : List α
⊢ l₁ ++ drop (length l₁) (l₁ ++ r) = l₁ ++ r
Theorem: CategoryTheory.GrothendieckTopology.sheafifyMap_comp
File: Mathlib/CategoryTheory/Sites/Sheafification.lean

tactic: dsimp [sheafifyMap, sheafify]
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q R : Cᵒᵖ ⥤ D
η : P ⟶ Q
γ : Q ⟶ R
⊢ sheafifyMap J (η ≫ γ) = sheafifyMap J η ≫ sheafifyMap J γ

tactic: simp
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
inst✝¹ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝ : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
P Q R : Cᵒᵖ ⥤ D
η : P ⟶ Q
γ : Q ⟶ R
⊢ plusMap J (plusMap J (η ≫ γ)) = plusMap J (plusMap J η) ≫ plusMap J (plusMap J γ)
Theorem: Algebra.TensorProduct.basis_repr_symm_apply'
File: Mathlib/RingTheory/TensorProduct.lean

tactic: simpa using basis_repr_symm_apply b r i
state_before: k : Type u_3
inst✝⁴ : CommRing k
R : Type u_1
inst✝³ : Ring R
inst✝² : Algebra k R
M : Type u_2
inst✝¹ : AddCommMonoid M
inst✝ : Module k M
ι : Type u_4
b : Basis ι k M
r : R
i : ι
⊢ r • ↑(basis R b) i = r ⊗ₜ[k] ↑b i
Theorem: div_lt_one
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [div_lt_iff hb, one_mul]
state_before: ι : Type ?u.76691
α : Type u_1
β : Type ?u.76697
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hb : 0 < b
⊢ a / b < 1 ↔ a < b
Theorem: MeasureTheory.exists_measurable_superset
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: simpa only [← measure_eq_trim] using μ.toOuterMeasure.exists_measurable_superset_eq_trim s
state_before: α : Type u_1
β : Type ?u.14385
γ : Type ?u.14388
δ : Type ?u.14391
ι : Type ?u.14394
inst✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
μ : Measure α
s : Set α
⊢ ∃ t, s ⊆ t ∧ MeasurableSet t ∧ ↑↑μ t = ↑↑μ s
Theorem: Real.continuousOn_log
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: simp only [continuousOn_iff_continuous_restrict, restrict]
state_before: x y : ℝ
⊢ ContinuousOn log ({0}ᶜ)

tactic: conv in log _ => rw [log_of_ne_zero (show (x : ℝ) ≠ 0 from x.2)]
state_before: x y : ℝ
⊢ Continuous fun x => log ↑x

tactic: exact expOrderIso.symm.continuous.comp (continuous_subtype_val.norm.subtype_mk _)
state_before: x y : ℝ
⊢ Continuous fun x => ↑(OrderIso.symm expOrderIso) { val := abs ↑x, property := (_ : 0 < abs ↑x) }
Theorem: RingFilterBasis.submodulesBasisIsBasis
File: Mathlib/Topology/Algebra/Nonarchimedean/Bases.lean

tactic: letI := BR.topology
state_before: ι : Type u_3
R : Type u_1
A : Type ?u.51903
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : Algebra R A
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
BR : RingFilterBasis R
B : ι → Submodule R M
hB : SubmodulesBasis BR B
x✝ : TopologicalSpace R := topology BR
⊢ ∀ (m : M) (i : ι), ∀ᶠ (a : R) in 𝓝 0, a • m ∈ B i

tactic: intro m i
state_before: ι : Type u_3
R : Type u_1
A : Type ?u.51903
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : Algebra R A
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
BR : RingFilterBasis R
B : ι → Submodule R M
hB : SubmodulesBasis BR B
x✝ : TopologicalSpace R := topology BR
this : TopologicalSpace R := topology BR
⊢ ∀ (m : M) (i : ι), ∀ᶠ (a : R) in 𝓝 0, a • m ∈ B i

tactic: rcases hB.smul m i with ⟨V, V_in, hV⟩
state_before: ι : Type u_3
R : Type u_1
A : Type ?u.51903
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : Algebra R A
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
BR : RingFilterBasis R
B : ι → Submodule R M
hB : SubmodulesBasis BR B
x✝ : TopologicalSpace R := topology BR
this : TopologicalSpace R := topology BR
m : M
i : ι
⊢ ∀ᶠ (a : R) in 𝓝 0, a • m ∈ B i

tactic: exact mem_of_superset (BR.toAddGroupFilterBasis.mem_nhds_zero V_in) hV
state_before: case intro.intro
ι : Type u_3
R : Type u_1
A : Type ?u.51903
inst✝⁴ : CommRing R
inst✝³ : CommRing A
inst✝² : Algebra R A
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
BR : RingFilterBasis R
B : ι → Submodule R M
hB : SubmodulesBasis BR B
x✝ : TopologicalSpace R := topology BR
this : TopologicalSpace R := topology BR
m : M
i : ι
V : Set R
V_in : V ∈ BR
hV : V ⊆ (fun x => x • m) ⁻¹' ↑(B i)
⊢ ∀ᶠ (a : R) in 𝓝 0, a • m ∈ B i
Theorem: Equiv.Perm.pow_mod_card_support_cycleOf_self_apply
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: by_cases hx : f x = x
state_before: ι : Type ?u.2520927
α : Type u_1
β : Type ?u.2520933
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x✝ y : α
f : Perm α
n : ℕ
x : α
⊢ ↑(f ^ (n % card (support (cycleOf f x)))) x = ↑(f ^ n) x

tactic: rw [pow_apply_eq_self_of_apply_eq_self hx, pow_apply_eq_self_of_apply_eq_self hx]
state_before: case pos
ι : Type ?u.2520927
α : Type u_1
β : Type ?u.2520933
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x✝ y : α
f : Perm α
n : ℕ
x : α
hx : ↑f x = x
⊢ ↑(f ^ (n % card (support (cycleOf f x)))) x = ↑(f ^ n) x

tactic: rw [← cycleOf_pow_apply_self, ← cycleOf_pow_apply_self f, ← (isCycle_cycleOf f hx).orderOf,
  ← pow_eq_mod_orderOf]
state_before: case neg
ι : Type ?u.2520927
α : Type u_1
β : Type ?u.2520933
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x✝ y : α
f : Perm α
n : ℕ
x : α
hx : ¬↑f x = x
⊢ ↑(f ^ (n % card (support (cycleOf f x)))) x = ↑(f ^ n) x
Theorem: Fin.repeat_add
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: generalize_proofs h
state_before: m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i : Fin n
y : α✝ (succ i)
z : α✝ 0
α : Type u_1
a : Fin n → α
m₁ m₂ : ℕ
⊢ repeat (m₁ + m₂) a = append (repeat m₁ a) (repeat m₂ a) ∘ ↑(cast (_ : (m₁ + m₂) * n = m₁ * n + m₂ * n))

tactic: apply funext
state_before: m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i : Fin n
y : α✝ (succ i)
z : α✝ 0
α : Type u_1
a : Fin n → α
m₁ m₂ : ℕ
h : (m₁ + m₂) * n = m₁ * n + m₂ * n
⊢ repeat (m₁ + m₂) a = append (repeat m₁ a) (repeat m₂ a) ∘ ↑(cast h)

tactic: rw [(Fin.cast h.symm).surjective.forall]
state_before: case h
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i : Fin n
y : α✝ (succ i)
z : α✝ 0
α : Type u_1
a : Fin n → α
m₁ m₂ : ℕ
h : (m₁ + m₂) * n = m₁ * n + m₂ * n
⊢ ∀ (x : Fin ((m₁ + m₂) * n)), repeat (m₁ + m₂) a x = (append (repeat m₁ a) (repeat m₂ a) ∘ ↑(cast h)) x

tactic: refine' Fin.addCases (fun l => _) fun r => _
state_before: case h
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i : Fin n
y : α✝ (succ i)
z : α✝ 0
α : Type u_1
a : Fin n → α
m₁ m₂ : ℕ
h : (m₁ + m₂) * n = m₁ * n + m₂ * n
⊢ ∀ (x : Fin (m₁ * n + m₂ * n)),
    repeat (m₁ + m₂) a (↑(cast (_ : m₁ * n + m₂ * n = (m₁ + m₂) * n)) x) =
      (append (repeat m₁ a) (repeat m₂ a) ∘ ↑(cast h)) (↑(cast (_ : m₁ * n + m₂ * n = (m₁ + m₂) * n)) x)

tactic: simp [modNat, Nat.mod_eq_of_lt l.is_lt]
state_before: case h.refine'_1
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i : Fin n
y : α✝ (succ i)
z : α✝ 0
α : Type u_1
a : Fin n → α
m₁ m₂ : ℕ
h : (m₁ + m₂) * n = m₁ * n + m₂ * n
l : Fin (m₁ * n)
⊢ repeat (m₁ + m₂) a (↑(cast (_ : m₁ * n + m₂ * n = (m₁ + m₂) * n)) (↑(castAdd (m₂ * n)) l)) =
    (append (repeat m₁ a) (repeat m₂ a) ∘ ↑(cast h))
      (↑(cast (_ : m₁ * n + m₂ * n = (m₁ + m₂) * n)) (↑(castAdd (m₂ * n)) l))

tactic: simp [modNat, Nat.add_mod]
state_before: case h.refine'_2
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i : Fin n
y : α✝ (succ i)
z : α✝ 0
α : Type u_1
a : Fin n → α
m₁ m₂ : ℕ
h : (m₁ + m₂) * n = m₁ * n + m₂ * n
r : Fin (m₂ * n)
⊢ repeat (m₁ + m₂) a (↑(cast (_ : m₁ * n + m₂ * n = (m₁ + m₂) * n)) (↑(natAdd (m₁ * n)) r)) =
    (append (repeat m₁ a) (repeat m₂ a) ∘ ↑(cast h))
      (↑(cast (_ : m₁ * n + m₂ * n = (m₁ + m₂) * n)) (↑(natAdd (m₁ * n)) r))
Theorem: neg_inv
File: Mathlib/Algebra/Field/Basic.lean

tactic: rw [inv_eq_one_div, inv_eq_one_div, div_neg_eq_neg_div]
state_before: α : Type ?u.34433
β : Type ?u.34436
K : Type u_1
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a b : K
⊢ -a⁻¹ = (-a)⁻¹
Theorem: Real.log_inv
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: by_cases hx : x = 0
state_before: x✝ y x : ℝ
⊢ log x⁻¹ = -log x

tactic: rw [← exp_eq_exp, exp_log_eq_abs (inv_ne_zero hx), exp_neg, exp_log_eq_abs hx, abs_inv]
state_before: case neg
x✝ y x : ℝ
hx : ¬x = 0
⊢ log x⁻¹ = -log x

tactic: simp [hx]
state_before: case pos
x✝ y x : ℝ
hx : x = 0
⊢ log x⁻¹ = -log x
Theorem: isOpenMap_sum_elim
File: Mathlib/Topology/Constructions.lean

tactic: simp only [isOpenMap_sum, elim_inl, elim_inr]
state_before: α : Type u
β : Type v
γ : Type u_1
δ : Type ?u.143893
ε : Type ?u.143896
ζ : Type ?u.143899
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → γ
g : β → γ
⊢ IsOpenMap (Sum.elim f g) ↔ IsOpenMap f ∧ IsOpenMap g
Theorem: CategoryTheory.MorphismProperty.surjective_stableUnderComposition
File: Mathlib/CategoryTheory/MorphismProperty.lean

tactic: delta MorphismProperty.surjective
state_before: C : Type u
inst✝² : Category C
D : Type ?u.89599
inst✝¹ : Category D
inst✝ : ConcreteCategory C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
hf : MorphismProperty.surjective C f
hg : MorphismProperty.surjective C g
⊢ MorphismProperty.surjective C (f ≫ g)

tactic: rw [coe_comp]
state_before: C : Type u
inst✝² : Category C
D : Type ?u.89599
inst✝¹ : Category D
inst✝ : ConcreteCategory C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
hf : MorphismProperty.surjective C f
hg : MorphismProperty.surjective C g
⊢ Surjective ((forget C).map (f ≫ g))

tactic: exact hg.comp hf
state_before: C : Type u
inst✝² : Category C
D : Type ?u.89599
inst✝¹ : Category D
inst✝ : ConcreteCategory C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
hf : MorphismProperty.surjective C f
hg : MorphismProperty.surjective C g
⊢ Surjective ((forget C).map g ∘ (forget C).map f)