tasksource/leandojo huggingface dataset:
Theorem: inducing_pullbackTotalSpaceEmbedding
File: Mathlib/Topology/FiberBundle/Constructions.lean

tactic: constructor
state_before: B : Type u
F : Type v
E : B → Type w₁
B' : Type w₂
f✝ : B' → B
inst✝¹ : TopologicalSpace B'
inst✝ : TopologicalSpace (TotalSpace E)
f : B' → B
⊢ Inducing (pullbackTotalSpaceEmbedding f)

tactic: simp_rw [instTopologicalSpaceProd, induced_inf, induced_compose,
  Pullback.TotalSpace.topologicalSpace, pullbackTopology_def]
state_before: case induced
B : Type u
F : Type v
E : B → Type w₁
B' : Type w₂
f✝ : B' → B
inst✝¹ : TopologicalSpace B'
inst✝ : TopologicalSpace (TotalSpace E)
f : B' → B
⊢ Pullback.TotalSpace.topologicalSpace E f = induced (pullbackTotalSpaceEmbedding f) instTopologicalSpaceProd

tactic: rfl
state_before: case induced
B : Type u
F : Type v
E : B → Type w₁
B' : Type w₂
f✝ : B' → B
inst✝¹ : TopologicalSpace B'
inst✝ : TopologicalSpace (TotalSpace E)
f : B' → B
⊢ induced TotalSpace.proj inst✝¹ ⊓ induced (Pullback.lift f) inst✝ =
    induced (Prod.fst ∘ pullbackTotalSpaceEmbedding f) inst✝¹ ⊓ induced (Prod.snd ∘ pullbackTotalSpaceEmbedding f) inst✝
Theorem: CategoryTheory.Injective.injective_iff_preservesEpimorphisms_yoneda_obj
File: Mathlib/CategoryTheory/Preadditive/Injective.lean

tactic: rw [injective_iff_projective_op, Projective.projective_iff_preservesEpimorphisms_coyoneda_obj]
state_before: C : Type u₁
inst✝ : Category C
J : C
⊢ Injective J ↔ Functor.PreservesEpimorphisms (yoneda.obj J)

tactic: exact Functor.preservesEpimorphisms.iso_iff (Coyoneda.objOpOp _)
state_before: C : Type u₁
inst✝ : Category C
J : C
⊢ Functor.PreservesEpimorphisms (coyoneda.obj J.op.op) ↔ Functor.PreservesEpimorphisms (yoneda.obj J)
Theorem: LowerSet.Iic_iInf₂
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp_rw [Iic_iInf]
state_before: α : Type u_1
β : Type ?u.121800
γ : Type ?u.121803
ι : Sort u_2
κ : ι → Sort u_3
inst✝ : CompleteLattice α
f : (i : ι) → κ i → α
⊢ Iic (⨅ (i : ι) (j : κ i), f i j) = ⨅ (i : ι) (j : κ i), Iic (f i j)
Theorem: Set.isWf_univ_iff
File: Mathlib/Order/WellFoundedSet.lean

tactic: simp [IsWf, wellFoundedOn_iff]
state_before: ι : Type ?u.36350
α : Type u_1
β : Type ?u.36356
inst✝ : LT α
s t : Set α
⊢ IsWf univ ↔ WellFounded fun x x_1 => x < x_1
Theorem: Set.PartiallyWellOrderedOn.iff_forall_not_isBadSeq
File: Mathlib/Order/WellFoundedSet.lean

tactic: simp [IsBadSeq]
state_before: ι : Type ?u.134113
α : Type u_1
β : Type ?u.134119
r✝ r : α → α → Prop
s : Set α
f : ℕ → α
⊢ ((∀ (n : ℕ), f n ∈ s) → ∃ m n, m < n ∧ r (f m) (f n)) ↔ ¬IsBadSeq r s f
Theorem: Nat.zero_lt_sub_of_lt
File: src/lean/Init/Data/Nat/Basic.lean

tactic: induction a with
| zero => contradiction
| succ a ih =>
  match Nat.eq_or_lt_of_le h with
  | Or.inl h => injection h with h; subst h; rw [←Nat.add_one, Nat.add_sub_self_left]; decide
  | Or.inr h =>
    have : 0 < a - i := ih (Nat.lt_of_succ_lt_succ h)
    exact Nat.lt_of_lt_of_le this (Nat.sub_le_succ_sub _ _)
state_before: i a : Nat
h : i < a
⊢ 0 < a - i

tactic: contradiction
state_before: case zero
i : Nat
h : i < zero
⊢ 0 < zero - i

tactic: match Nat.eq_or_lt_of_le h with
| Or.inl h => injection h with h; subst h; rw [←Nat.add_one, Nat.add_sub_self_left]; decide
| Or.inr h =>
  have : 0 < a - i := ih (Nat.lt_of_succ_lt_succ h)
  exact Nat.lt_of_lt_of_le this (Nat.sub_le_succ_sub _ _)
state_before: case succ
i a : Nat
ih : i < a → 0 < a - i
h : i < succ a
⊢ 0 < succ a - i

tactic: injection h with h
state_before: i a : Nat
ih : i < a → 0 < a - i
h✝ : i < succ a
h : succ i = succ a
⊢ 0 < succ a - i

tactic: subst h
state_before: i a : Nat
ih : i < a → 0 < a - i
h✝ : i < succ a
h : i = a
⊢ 0 < succ a - i

tactic: rw [←Nat.add_one, Nat.add_sub_self_left]
state_before: i : Nat
ih : i < i → 0 < i - i
h : i < succ i
⊢ 0 < succ i - i

tactic: decide
state_before: i : Nat
ih : i < i → 0 < i - i
h : i < succ i
⊢ 0 < 1

tactic: have : 0 < a - i := ih (Nat.lt_of_succ_lt_succ h)
state_before: i a : Nat
ih : i < a → 0 < a - i
h✝ : i < succ a
h : succ i < succ a
⊢ 0 < succ a - i

tactic: exact Nat.lt_of_lt_of_le this (Nat.sub_le_succ_sub _ _)
state_before: i a : Nat
ih : i < a → 0 < a - i
h✝ : i < succ a
h : succ i < succ a
this : 0 < a - i
⊢ 0 < succ a - i
Theorem: List.map_prod_left_eq_zip
File: Mathlib/Data/List/Zip.lean

tactic: rw [← zip_map']
state_before: α : Type u
β : Type u_1
γ : Type ?u.87662
δ : Type ?u.87665
ε : Type ?u.87668
l : List α
f : α → β
⊢ map (fun x => (x, f x)) l = zip l (map f l)

tactic: congr
state_before: α : Type u
β : Type u_1
γ : Type ?u.87662
δ : Type ?u.87665
ε : Type ?u.87668
l : List α
f : α → β
⊢ zip (map (fun x => x) l) (map (fun x => f x) l) = zip l (map f l)

tactic: exact map_id _
state_before: case e_a
α : Type u
β : Type u_1
γ : Type ?u.87662
δ : Type ?u.87665
ε : Type ?u.87668
l : List α
f : α → β
⊢ map (fun x => x) l = l
Theorem: MeasureTheory.integrableOn_map_equiv
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: simp only [IntegrableOn, e.restrict_map, integrable_map_equiv e]
state_before: α : Type u_2
β : Type u_1
E : Type u_3
F : Type ?u.1520469
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f✝ g : α → E
s✝ t : Set α
μ✝ ν : Measure α
inst✝ : MeasurableSpace β
e : α ≃ᵐ β
f : β → E
μ : Measure α
s : Set β
⊢ IntegrableOn f s ↔ IntegrableOn (f ∘ ↑e) (↑e ⁻¹' s)
Theorem: CategoryTheory.Limits.WidePushout.head_desc
File: Mathlib/CategoryTheory/Limits/Shapes/WidePullbacks.lean

tactic: simp only [colimit.ι_desc, WidePushoutShape.mkCocone_pt, WidePushoutShape.mkCocone_ι_app]
state_before: J : Type w
C : Type u
inst✝² : Category C
D : Type u_1
inst✝¹ : Category D
B : D
objs : J → D
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : D
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
⊢ head arrows ≫ desc f fs w = f
Theorem: Set.toFinset_singleton
File: Mathlib/Data/Fintype/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.97519
γ : Type ?u.97522
s t : Set α
a : α
inst✝ : Fintype ↑{a}
⊢ toFinset {a} = {a}

tactic: simp
state_before: case a
α : Type u_1
β : Type ?u.97519
γ : Type ?u.97522
s t : Set α
a : α
inst✝ : Fintype ↑{a}
a✝ : α
⊢ a✝ ∈ toFinset {a} ↔ a✝ ∈ {a}
Theorem: AlgebraicTopology.DoldKan.Hσ_eq_zero
File: Mathlib/AlgebraicTopology/DoldKan/Homotopies.lean

tactic: unfold Hσ
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q : ℕ
⊢ HomologicalComplex.Hom.f (Hσ q) 0 = 0

tactic: rw [nullHomotopicMap'_f_of_not_rel_left (c_mk 1 0 rfl) cs_down_0_not_rel_left]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q : ℕ
⊢ HomologicalComplex.Hom.f (nullHomotopicMap' (hσ' q)) 0 = 0

tactic: rcases q with (_|q)
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q : ℕ
⊢ hσ' q 0 1 (_ : ComplexShape.Rel c 1 0) ≫ HomologicalComplex.d K[X] 1 0 = 0

tactic: rw [hσ'_eq (show 0 = 0 + 0 by rfl) (c_mk 1 0 rfl)]
state_before: case zero
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
⊢ hσ' Nat.zero 0 1 (_ : ComplexShape.Rel c 1 0) ≫ HomologicalComplex.d K[X] 1 0 = 0

tactic: simp only [pow_zero, Fin.mk_zero, one_zsmul, eqToHom_refl, Category.comp_id]
state_before: case zero
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
⊢ (((-1) ^ 0 • σ X { val := 0, isLt := (_ : 0 < Nat.succ 0) }) ≫ eqToHom (_ : X.obj [0 + 1].op = X.obj [1].op)) ≫
      HomologicalComplex.d K[X] 1 0 =
    0

tactic: erw [ChainComplex.of_d]
state_before: case zero
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
⊢ σ X 0 ≫ HomologicalComplex.d K[X] 1 0 = 0

tactic: rw [AlternatingFaceMapComplex.objD, Fin.sum_univ_two, Fin.val_zero, Fin.val_one, pow_zero,
  pow_one, one_smul, neg_smul, one_smul, comp_add, comp_neg, add_neg_eq_zero]
state_before: case zero
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
⊢ σ X 0 ≫ AlternatingFaceMapComplex.objD X 0 = 0

tactic: erw [δ_comp_σ_self, δ_comp_σ_succ]
state_before: case zero
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
⊢ σ X 0 ≫ δ X 0 = σ X 0 ≫ δ X 1

tactic: rfl
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
⊢ 0 = 0 + 0

tactic: rw [hσ'_eq_zero (Nat.succ_pos q) (c_mk 1 0 rfl), zero_comp]
state_before: case succ
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q : ℕ
⊢ hσ' (Nat.succ q) 0 1 (_ : ComplexShape.Rel c 1 0) ≫ HomologicalComplex.d K[X] 1 0 = 0
Theorem: Real.one_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: simp [rpow_def]
state_before: x : ℝ
⊢ 1 ^ x = 1
Theorem: IntervalIntegrable.trans_iterate_Ico
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: revert hint
state_before: ι : Type ?u.2084269
𝕜 : Type ?u.2084272
E : Type u_1
F : Type ?u.2084278
A : Type ?u.2084281
inst✝ : NormedAddCommGroup E
f : ℝ → E
a✝ b c d : ℝ
μ ν : MeasureTheory.Measure ℝ
a : ℕ → ℝ
m n : ℕ
hmn : m ≤ n
hint : ∀ (k : ℕ), k ∈ Ico m n → IntervalIntegrable f μ (a k) (a (k + 1))
⊢ IntervalIntegrable f μ (a m) (a n)

tactic: refine' Nat.le_induction _ _ n hmn
state_before: ι : Type ?u.2084269
𝕜 : Type ?u.2084272
E : Type u_1
F : Type ?u.2084278
A : Type ?u.2084281
inst✝ : NormedAddCommGroup E
f : ℝ → E
a✝ b c d : ℝ
μ ν : MeasureTheory.Measure ℝ
a : ℕ → ℝ
m n : ℕ
hmn : m ≤ n
⊢ (∀ (k : ℕ), k ∈ Ico m n → IntervalIntegrable f μ (a k) (a (k + 1))) → IntervalIntegrable f μ (a m) (a n)

tactic: simp
state_before: case refine'_1
ι : Type ?u.2084269
𝕜 : Type ?u.2084272
E : Type u_1
F : Type ?u.2084278
A : Type ?u.2084281
inst✝ : NormedAddCommGroup E
f : ℝ → E
a✝ b c d : ℝ
μ ν : MeasureTheory.Measure ℝ
a : ℕ → ℝ
m n : ℕ
hmn : m ≤ n
⊢ (∀ (k : ℕ), k ∈ Ico m m → IntervalIntegrable f μ (a k) (a (k + 1))) → IntervalIntegrable f μ (a m) (a m)

tactic: intro p hp IH h
state_before: case refine'_2
ι : Type ?u.2084269
𝕜 : Type ?u.2084272
E : Type u_1
F : Type ?u.2084278
A : Type ?u.2084281
inst✝ : NormedAddCommGroup E
f : ℝ → E
a✝ b c d : ℝ
μ ν : MeasureTheory.Measure ℝ
a : ℕ → ℝ
m n : ℕ
hmn : m ≤ n
⊢ ∀ (n : ℕ),
    m ≤ n →
      ((∀ (k : ℕ), k ∈ Ico m n → IntervalIntegrable f μ (a k) (a (k + 1))) → IntervalIntegrable f μ (a m) (a n)) →
        (∀ (k : ℕ), k ∈ Ico m (n + 1) → IntervalIntegrable f μ (a k) (a (k + 1))) →
          IntervalIntegrable f μ (a m) (a (n + 1))

tactic: exact (IH fun k hk => h k (Ico_subset_Ico_right p.le_succ hk)).trans (h p (by simp [hp]))
state_before: case refine'_2
ι : Type ?u.2084269
𝕜 : Type ?u.2084272
E : Type u_1
F : Type ?u.2084278
A : Type ?u.2084281
inst✝ : NormedAddCommGroup E
f : ℝ → E
a✝ b c d : ℝ
μ ν : MeasureTheory.Measure ℝ
a : ℕ → ℝ
m n : ℕ
hmn : m ≤ n
p : ℕ
hp : m ≤ p
IH : (∀ (k : ℕ), k ∈ Ico m p → IntervalIntegrable f μ (a k) (a (k + 1))) → IntervalIntegrable f μ (a m) (a p)
h : ∀ (k : ℕ), k ∈ Ico m (p + 1) → IntervalIntegrable f μ (a k) (a (k + 1))
⊢ IntervalIntegrable f μ (a m) (a (p + 1))

tactic: simp [hp]
state_before: ι : Type ?u.2084269
𝕜 : Type ?u.2084272
E : Type u_1
F : Type ?u.2084278
A : Type ?u.2084281
inst✝ : NormedAddCommGroup E
f : ℝ → E
a✝ b c d : ℝ
μ ν : MeasureTheory.Measure ℝ
a : ℕ → ℝ
m n : ℕ
hmn : m ≤ n
p : ℕ
hp : m ≤ p
IH : (∀ (k : ℕ), k ∈ Ico m p → IntervalIntegrable f μ (a k) (a (k + 1))) → IntervalIntegrable f μ (a m) (a p)
h : ∀ (k : ℕ), k ∈ Ico m (p + 1) → IntervalIntegrable f μ (a k) (a (k + 1))
⊢ p ∈ Ico m (p + 1)
Theorem: CategoryTheory.IsPushout.IsVanKampen.isPullback_of_mono_right
File: Mathlib/CategoryTheory/Adhesive.lean

tactic: simp
state_before: J : Type v'
inst✝² : Category J
C : Type u
inst✝¹ : Category C
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
inst✝ : Mono g
H : IsPushout f g h i
H' : IsVanKampen H
⊢ f ≫ 𝟙 X = 𝟙 W ≫ f

tactic: simp
state_before: J : Type v'
inst✝² : Category J
C : Type u
inst✝¹ : Category C
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
inst✝ : Mono g
H : IsPushout f g h i
H' : IsVanKampen H
⊢ f ≫ 𝟙 X = 𝟙 W ≫ f

tactic: simp
state_before: J : Type v'
inst✝² : Category J
C : Type u
inst✝¹ : Category C
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
inst✝ : Mono g
H : IsPushout f g h i
H' : IsVanKampen H
⊢ f ≫ 𝟙 X = 𝟙 W ≫ f
Theorem: OnePoint.isClosed_iff_of_not_mem
File: Mathlib/Topology/Compactification/OnePoint.lean

tactic: rw [← isOpen_compl_iff, isOpen_iff_of_mem (mem_compl h), ← preimage_compl, compl_compl]
state_before: X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
h : ¬∞ ∈ s
⊢ IsClosed s ↔ IsClosed (some ⁻¹' s) ∧ IsCompact (some ⁻¹' s)
Theorem: Nat.sum_divisors_filter_squarefree
File: Mathlib/Data/Nat/Squarefree.lean

tactic: rw [Finset.sum_eq_multiset_sum, divisors_filter_squarefree h0, Multiset.map_map,
  Finset.sum_eq_multiset_sum]
state_before: n : ℕ
h0 : n ≠ 0
α : Type u_1
inst✝ : AddCommMonoid α
f : ℕ → α
⊢ ∑ i in Finset.filter Squarefree (divisors n), f i =
    ∑ i in Finset.powerset (Multiset.toFinset (normalizedFactors n)), f (Multiset.prod i.val)

tactic: rfl
state_before: n : ℕ
h0 : n ≠ 0
α : Type u_1
inst✝ : AddCommMonoid α
f : ℕ → α
⊢ Multiset.sum
      (Multiset.map ((fun i => f i) ∘ fun x => Multiset.prod x.val)
        (Finset.powerset (Multiset.toFinset (normalizedFactors n))).val) =
    Multiset.sum
      (Multiset.map (fun i => f (Multiset.prod i.val)) (Finset.powerset (Multiset.toFinset (normalizedFactors n))).val)
Theorem: Multiset.add_union_distrib
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [add_comm, union_add_distrib, add_comm s, add_comm s]
state_before: α : Type u_1
β : Type ?u.187191
γ : Type ?u.187194
inst✝ : DecidableEq α
s✝ t✝ u✝ : Multiset α
a b : α
s t u : Multiset α
⊢ s + (t ∪ u) = s + t ∪ (s + u)
Theorem: ChainClosure.succ_fixpoint
File: Mathlib/Order/Chain.lean

tactic: induction hc₁
state_before: α : Type u_1
β : Type ?u.13163
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
hc₁ : ChainClosure r c₁
hc₂ : ChainClosure r c₂
hc : SuccChain r c₂ = c₂
⊢ c₁ ⊆ c₂

tactic: case succ s₁ hc₁ h => exact (chainClosure_succ_total hc₁ hc₂ h).elim (fun h => h ▸ hc.subset) id
state_before: case succ
α : Type u_1
β : Type ?u.13163
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
hc₂ : ChainClosure r c₂
hc : SuccChain r c₂ = c₂
s✝ : Set α
a✝ : ChainClosure r s✝
a_ih✝ : s✝ ⊆ c₂
⊢ SuccChain r s✝ ⊆ c₂

case union
α : Type u_1
β : Type ?u.13163
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
hc₂ : ChainClosure r c₂
hc : SuccChain r c₂ = c₂
s✝ : Set (Set α)
a✝ : ∀ (a : Set α), a ∈ s✝ → ChainClosure r a
a_ih✝ : ∀ (a : Set α), a ∈ s✝ → a ⊆ c₂
⊢ ⋃₀ s✝ ⊆ c₂

tactic: case union s _ ih => exact sUnion_subset ih
state_before: case union
α : Type u_1
β : Type ?u.13163
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
hc₂ : ChainClosure r c₂
hc : SuccChain r c₂ = c₂
s✝ : Set (Set α)
a✝ : ∀ (a : Set α), a ∈ s✝ → ChainClosure r a
a_ih✝ : ∀ (a : Set α), a ∈ s✝ → a ⊆ c₂
⊢ ⋃₀ s✝ ⊆ c₂

tactic: exact (chainClosure_succ_total hc₁ hc₂ h).elim (fun h => h ▸ hc.subset) id
state_before: α : Type u_1
β : Type ?u.13163
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
hc₂ : ChainClosure r c₂
hc : SuccChain r c₂ = c₂
s₁ : Set α
hc₁ : ChainClosure r s₁
h : s₁ ⊆ c₂
⊢ SuccChain r s₁ ⊆ c₂

tactic: exact sUnion_subset ih
state_before: α : Type u_1
β : Type ?u.13163
r : α → α → Prop
c c₁ c₂ c₃ s✝ t : Set α
a b x y : α
hc₂ : ChainClosure r c₂
hc : SuccChain r c₂ = c₂
s : Set (Set α)
a✝ : ∀ (a : Set α), a ∈ s → ChainClosure r a
ih : ∀ (a : Set α), a ∈ s → a ⊆ c₂
⊢ ⋃₀ s ⊆ c₂
Theorem: finprod_mem_inter_mulSupport_eq'
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: apply finprod_mem_inter_mulSupport_eq
state_before: α : Type u_1
β : Type ?u.208648
ι : Type ?u.208651
G : Type ?u.208654
M : Type u_2
N : Type ?u.208660
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
s t : Set α
h : ∀ (x : α), x ∈ mulSupport f → (x ∈ s ↔ x ∈ t)
⊢ (∏ᶠ (i : α) (_ : i ∈ s), f i) = ∏ᶠ (i : α) (_ : i ∈ t), f i

tactic: ext x
state_before: case h
α : Type u_1
β : Type ?u.208648
ι : Type ?u.208651
G : Type ?u.208654
M : Type u_2
N : Type ?u.208660
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
s t : Set α
h : ∀ (x : α), x ∈ mulSupport f → (x ∈ s ↔ x ∈ t)
⊢ (s ∩ mulSupport fun i => f i) = t ∩ mulSupport fun i => f i

tactic: exact and_congr_left (h x)
state_before: case h.h
α : Type u_1
β : Type ?u.208648
ι : Type ?u.208651
G : Type ?u.208654
M : Type u_2
N : Type ?u.208660
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
s t : Set α
h : ∀ (x : α), x ∈ mulSupport f → (x ∈ s ↔ x ∈ t)
x : α
⊢ (x ∈ s ∩ mulSupport fun i => f i) ↔ x ∈ t ∩ mulSupport fun i => f i
Theorem: MeasureTheory.OuterMeasure.sUnion_null_iff
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: rw [sUnion_eq_biUnion, m.biUnion_null_iff hS]
state_before: α : Type u_1
β : Type ?u.7681
R : Type ?u.7684
R' : Type ?u.7687
ms : Set (OuterMeasure α)
m✝ m : OuterMeasure α
S : Set (Set α)
hS : Set.Countable S
⊢ ↑m (⋃₀ S) = 0 ↔ ∀ (s : Set α), s ∈ S → ↑m s = 0
Theorem: PGame.add_left_neg_le_zero
File: Mathlib/SetTheory/Game/PGame.lean

tactic: cases' i with i i
state_before: xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
i : LeftMoves (-mk xl xr xL xR + mk xl xr xL xR)
⊢ ∃ j, moveRight (moveLeft (-mk xl xr xL xR + mk xl xr xL xR) i) j ≤ 0

tactic: refine' ⟨@toRightMovesAdd _ ⟨_, _, _, _⟩ (Sum.inr i), _⟩
state_before: case inl
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
i : xr
⊢ ∃ j, moveRight (moveLeft (-mk xl xr xL xR + mk xl xr xL xR) (Sum.inl i)) j ≤ 0

tactic: convert @add_left_neg_le_zero (xR i)
state_before: case inl
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
i : xr
⊢ moveRight (moveLeft (-mk xl xr xL xR + mk xl xr xL xR) (Sum.inl i)) (↑toRightMovesAdd (Sum.inr i)) ≤ 0

tactic: apply add_moveRight_inr
state_before: case h.e'_3
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
i : xr
⊢ moveRight (moveLeft (-mk xl xr xL xR + mk xl xr xL xR) (Sum.inl i)) (↑toRightMovesAdd (Sum.inr i)) = -xR i + xR i

tactic: dsimp
state_before: case inr
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
i : xl
⊢ ∃ j, moveRight (moveLeft (-mk xl xr xL xR + mk xl xr xL xR) (Sum.inr i)) j ≤ 0

tactic: refine' ⟨@toRightMovesAdd ⟨_, _, _, _⟩ _ (Sum.inl i), _⟩
state_before: case inr
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
i : xl
⊢ ∃ j, moveRight ((mk xr xl (fun j => -xR j) fun i => -xL i) + xL i) j ≤ 0

tactic: convert @add_left_neg_le_zero (xL i)
state_before: case inr
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
i : xl
⊢ moveRight ((mk xr xl (fun j => -xR j) fun i => -xL i) + xL i) (↑toRightMovesAdd (Sum.inl i)) ≤ 0

tactic: apply add_moveRight_inl
state_before: case h.e'_3
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
i : xl
⊢ moveRight ((mk xr xl (fun j => -xR j) fun i => -xL i) + xL i) (↑toRightMovesAdd (Sum.inl i)) = -xL i + xL i
Theorem: Fin.lt_add_one_iff
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [← not_iff_not]
state_before: n✝ m n : ℕ
k : Fin (n + 1)
⊢ k < k + 1 ↔ k < last n

tactic: simp
state_before: n✝ m n : ℕ
k : Fin (n + 1)
⊢ ¬k < k + 1 ↔ ¬k < last n
Theorem: Complex.continuous_cos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: change Continuous fun z => (exp (z * I) + exp (-z * I)) / 2
state_before: ⊢ Continuous cos

tactic: continuity
state_before: ⊢ Continuous fun z => (exp (z * I) + exp (-z * I)) / 2
Theorem: IndexedPartition.iUnion
File: Mathlib/Data/Setoid/Partition.lean

tactic: ext x
state_before: ι : Type u_2
α : Type u_1
s : ι → Set α
hs : IndexedPartition s
⊢ (⋃ (i : ι), s i) = univ

tactic: simp [hs.exists_mem x]
state_before: case h
ι : Type u_2
α : Type u_1
s : ι → Set α
hs : IndexedPartition s
x : α
⊢ (x ∈ ⋃ (i : ι), s i) ↔ x ∈ univ
Theorem: Nat.card_fintypeIio
File: Mathlib/Data/Nat/Interval.lean

tactic: rw [Fintype.card_ofFinset, card_Iio]
state_before: a b c : ℕ
⊢ Fintype.card ↑(Set.Iio b) = b
Theorem: Equiv.Perm.IsCycle.swap_mul
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: simp [swap_apply_def, mul_apply, if_neg hffx, f.injective.eq_iff, if_neg hx, hx]
state_before: ι : Type ?u.819516
α✝ : Type ?u.819519
β : Type ?u.819522
f✝ g : Perm α✝
x✝ y : α✝
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_1
inst✝ : DecidableEq α
f : Perm α
hf : IsCycle f
x : α
hx : ↑f x ≠ x
hffx : ↑f (↑f x) ≠ x
⊢ ↑(swap x (↑f x) * f) (↑f x) ≠ ↑f x

tactic: simp
state_before: ι : Type ?u.819516
α✝ : Type ?u.819519
β : Type ?u.819522
f✝ g : Perm α✝
x✝ y✝ : α✝
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_1
inst✝ : DecidableEq α
f : Perm α
hf : IsCycle f
x : α
hx : ↑f x ≠ x
hffx : ↑f (↑f x) ≠ x
y : α
hy : ↑(swap x (↑f x) * f) y ≠ y
i : ℤ
hi : ↑(f ^ i) x = y
⊢ ↑(f ^ (i - 1)) (↑f x) = ↑(f ^ (i - 1) * f ^ 1) x

tactic: rwa [← zpow_add, sub_add_cancel]
state_before: ι : Type ?u.819516
α✝ : Type ?u.819519
β : Type ?u.819522
f✝ g : Perm α✝
x✝ y✝ : α✝
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_1
inst✝ : DecidableEq α
f : Perm α
hf : IsCycle f
x : α
hx : ↑f x ≠ x
hffx : ↑f (↑f x) ≠ x
y : α
hy : ↑(swap x (↑f x) * f) y ≠ y
i : ℤ
hi : ↑(f ^ i) x = y
⊢ ↑(f ^ (i - 1) * f ^ 1) x = y
Theorem: PrimeSpectrum.zeroLocus_vanishingIdeal_eq_closure
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: apply Set.Subset.antisymm
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
t : Set (PrimeSpectrum R)
⊢ zeroLocus ↑(vanishingIdeal t) = closure t

tactic: rintro x hx t' ⟨ht', ht⟩
state_before: case h₁
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
t : Set (PrimeSpectrum R)
⊢ zeroLocus ↑(vanishingIdeal t) ⊆ closure t

tactic: obtain ⟨fs, rfl⟩ : ∃ s, t' = zeroLocus s := by rwa [isClosed_iff_zeroLocus] at ht'
state_before: case h₁.intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
t : Set (PrimeSpectrum R)
x : PrimeSpectrum R
hx : x ∈ zeroLocus ↑(vanishingIdeal t)
t' : Set (PrimeSpectrum R)
ht' : IsClosed t'
ht : t ⊆ t'
⊢ x ∈ t'

tactic: rw [subset_zeroLocus_iff_subset_vanishingIdeal] at ht
state_before: case h₁.intro.intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
t : Set (PrimeSpectrum R)
x : PrimeSpectrum R
hx : x ∈ zeroLocus ↑(vanishingIdeal t)
fs : Set R
ht' : IsClosed (zeroLocus fs)
ht : t ⊆ zeroLocus fs
⊢ x ∈ zeroLocus fs

tactic: exact Set.Subset.trans ht hx
state_before: case h₁.intro.intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
t : Set (PrimeSpectrum R)
x : PrimeSpectrum R
hx : x ∈ zeroLocus ↑(vanishingIdeal t)
fs : Set R
ht' : IsClosed (zeroLocus fs)
ht : fs ⊆ ↑(vanishingIdeal t)
⊢ x ∈ zeroLocus fs

tactic: rwa [isClosed_iff_zeroLocus] at ht'
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
t : Set (PrimeSpectrum R)
x : PrimeSpectrum R
hx : x ∈ zeroLocus ↑(vanishingIdeal t)
t' : Set (PrimeSpectrum R)
ht' : IsClosed t'
ht : t ⊆ t'
⊢ ∃ s, t' = zeroLocus s

tactic: rw [(isClosed_zeroLocus _).closure_subset_iff]
state_before: case h₂
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
t : Set (PrimeSpectrum R)
⊢ closure t ⊆ zeroLocus ↑(vanishingIdeal t)

tactic: exact subset_zeroLocus_vanishingIdeal t
state_before: case h₂
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
t : Set (PrimeSpectrum R)
⊢ t ⊆ zeroLocus ↑(vanishingIdeal t)
Theorem: FirstOrder.Language.Substructure.cg_iff_countable
File: Mathlib/ModelTheory/FinitelyGenerated.lean

tactic: refine' ⟨_, fun h => ⟨s, h.to_set, s.closure_eq⟩⟩
state_before: L : Language
M : Type u_3
inst✝¹ : Structure L M
inst✝ : Countable ((l : ℕ) × Functions L l)
s : Substructure L M
⊢ CG s ↔ Countable { x // x ∈ s }

tactic: rintro ⟨s, h, rfl⟩
state_before: L : Language
M : Type u_3
inst✝¹ : Structure L M
inst✝ : Countable ((l : ℕ) × Functions L l)
s : Substructure L M
⊢ CG s → Countable { x // x ∈ s }

tactic: exact h.substructure_closure L
state_before: case intro.intro
L : Language
M : Type u_3
inst✝¹ : Structure L M
inst✝ : Countable ((l : ℕ) × Functions L l)
s : Set M
h : Set.Countable s
⊢ Countable { x // x ∈ LowerAdjoint.toFun (closure L) s }
Theorem: Nat.dvd_trans
File: Std/Data/Nat/Lemmas.lean

tactic: simp[h₃,h₄, Nat.mul_assoc]
state_before: a b c : Nat
h₁ : a ∣ b
h₂ : b ∣ c
d : Nat
h₃ : b = a * d
e : Nat
h₄ : c = b * e
⊢ c = a * (d * e)
Theorem: le_sup_sdiff_sup_sdiff
File: Mathlib/Order/Heyting/Basic.lean

tactic: simpa using @sdiff_sdiff_sdiff_le_sdiff
state_before: ι : Type ?u.95313
α : Type u_1
β : Type ?u.95319
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a ≤ b ⊔ (a \ c ⊔ c \ b)