tasksource/leandojo huggingface dataset:
Theorem: Finset.filter_or
File: Mathlib/Data/Finset/Basic.lean

tactic: simp [mem_filter, mem_union, and_or_left]
state_before: α : Type u_1
β : Type ?u.391377
γ : Type ?u.391380
p q : α → Prop
inst✝² : DecidablePred p
inst✝¹ : DecidablePred q
inst✝ : DecidableEq α
s : Finset α
x✝ : α
⊢ x✝ ∈ filter (fun a => p a ∨ q a) s ↔ x✝ ∈ filter p s ∪ filter q s
Theorem: Set.mulIndicator_self_mul_compl_apply
File: Mathlib/Algebra/IndicatorFunction.lean

tactic: simp [ha]
state_before: α : Type u_1
β : Type ?u.61897
ι : Type ?u.61900
M : Type u_2
N : Type ?u.61906
inst✝ : MulOneClass M
s✝ t : Set α
f✝ g : α → M
a✝ : α
s : Set α
f : α → M
a : α
ha : a ∈ s
⊢ mulIndicator s f a * mulIndicator (sᶜ) f a = f a

tactic: simp [ha]
state_before: α : Type u_1
β : Type ?u.61897
ι : Type ?u.61900
M : Type u_2
N : Type ?u.61906
inst✝ : MulOneClass M
s✝ t : Set α
f✝ g : α → M
a✝ : α
s : Set α
f : α → M
a : α
ha : ¬a ∈ s
⊢ mulIndicator s f a * mulIndicator (sᶜ) f a = f a
Theorem: Finset.image₂_left_identity
File: Mathlib/Data/Finset/NAry.lean

tactic: rw [coe_image₂, coe_singleton, Set.image2_left_identity h]
state_before: α : Type u_2
α' : Type ?u.98648
β : Type ?u.98651
β' : Type ?u.98654
γ : Type u_1
γ' : Type ?u.98660
δ : Type ?u.98663
δ' : Type ?u.98666
ε : Type ?u.98669
ε' : Type ?u.98672
ζ : Type ?u.98675
ζ' : Type ?u.98678
ν : Type ?u.98681
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f✝ f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t✝ t' : Finset β
u u' : Finset γ
a✝ a' : α
b b' : β
c : γ
f : α → γ → γ
a : α
h : ∀ (b : γ), f a b = b
t : Finset γ
⊢ ↑(image₂ f {a} t) = ↑t
Theorem: Complex.continuous_circleTransformDeriv
File: Mathlib/MeasureTheory/Integral/CircleTransform.lean

tactic: rw [circleTransformDeriv_eq]
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
R✝ : ℝ
z✝ w✝ : ℂ
R : ℝ
hR : 0 < R
f : ℂ → E
z w : ℂ
hf : ContinuousOn f (sphere z R)
hw : w ∈ ball z R
⊢ Continuous (circleTransformDeriv R z w f)

tactic: exact (continuous_circleMap_inv hw).smul (continuous_circleTransform hR hf hw)
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
R✝ : ℝ
z✝ w✝ : ℂ
R : ℝ
hR : 0 < R
f : ℂ → E
z w : ℂ
hf : ContinuousOn f (sphere z R)
hw : w ∈ ball z R
⊢ Continuous fun θ => (circleMap z R θ - w)⁻¹ • circleTransform R z w f θ
Theorem: CategoryTheory.Limits.biproduct.ι_π
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: convert (biproduct.bicone f).ι_π j j'
state_before: J : Type w
C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
inst✝¹ : DecidableEq J
f : J → C
inst✝ : HasBiproduct f
j j' : J
⊢ ι f j ≫ π f j' = if h : j = j' then eqToHom (_ : f j = f j') else 0
Theorem: Real.mk_pos
File: Mathlib/Data/Real/Basic.lean

tactic: rw [← mk_zero, mk_lt]
state_before: x y : ℝ
f : CauSeq ℚ abs
⊢ 0 < mk f ↔ Pos f

tactic: exact iff_of_eq (congr_arg Pos (sub_zero f))
state_before: x y : ℝ
f : CauSeq ℚ abs
⊢ 0 < f ↔ Pos f
Theorem: rank_prod
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: simpa [rank_eq_card_chooseBasisIndex K V, rank_eq_card_chooseBasisIndex K V', lift_umax,
  lift_umax'] using ((chooseBasis K V).prod (chooseBasis K V')).mk_eq_rank.symm
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.495590
inst✝¹⁰ : Ring K
inst✝⁹ : StrongRankCondition K
inst✝⁸ : AddCommGroup V
inst✝⁷ : Module K V
inst✝⁶ : Module.Free K V
inst✝⁵ : AddCommGroup V'
inst✝⁴ : Module K V'
inst✝³ : Module.Free K V'
inst✝² : AddCommGroup V₁
inst✝¹ : Module K V₁
inst✝ : Module.Free K V₁
⊢ Module.rank K (V × V') = lift (Module.rank K V) + lift (Module.rank K V')
Theorem: Finmap.induction_on
File: Mathlib/Data/Finmap.lean

tactic: rcases s with ⟨⟨a⟩, h⟩
state_before: α : Type u
β : α → Type v
C : Finmap β → Prop
s : Finmap β
H : ∀ (a : AList β), C ⟦a⟧
⊢ C s

tactic: exact H ⟨a, h⟩
state_before: case mk.mk
α : Type u
β : α → Type v
C : Finmap β → Prop
H : ∀ (a : AList β), C ⟦a⟧
entries✝ : Multiset (Sigma β)
a : List (Sigma β)
h : Multiset.NodupKeys (Quot.mk Setoid.r a)
⊢ C { entries := Quot.mk Setoid.r a, nodupKeys := h }
Theorem: CategoryTheory.CosimplicialObject.σ_comp_σ
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

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

tactic: simp only [← X.map_comp, SimplexCategory.σ_comp_σ H]
state_before: C : Type u
inst✝ : Category C
X : CosimplicialObject C
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
⊢ X.map (SimplexCategory.σ (↑Fin.castSucc i)) ≫ X.map (SimplexCategory.σ j) =
    X.map (SimplexCategory.σ (Fin.succ j)) ≫ X.map (SimplexCategory.σ i)
Theorem: Matrix.transpose_col
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.1213810
m : Type u_1
n : Type ?u.1213816
o : Type ?u.1213819
m' : o → Type ?u.1213824
n' : o → Type ?u.1213829
R : Type ?u.1213832
S : Type ?u.1213835
α : Type v
β : Type w
γ : Type ?u.1213842
v : m → α
⊢ (col v)ᵀ = row v

tactic: rfl
state_before: case a.h
l : Type ?u.1213810
m : Type u_1
n : Type ?u.1213816
o : Type ?u.1213819
m' : o → Type ?u.1213824
n' : o → Type ?u.1213829
R : Type ?u.1213832
S : Type ?u.1213835
α : Type v
β : Type w
γ : Type ?u.1213842
v : m → α
i✝ : Unit
x✝ : m
⊢ (col v)ᵀ i✝ x✝ = row v i✝ x✝
Theorem: Nat.zero_lt_one_add
File: Mathlib/Init/Meta/WellFoundedTactics.lean

tactic: simp [Nat.add_comm]
state_before: a : ℕ
this : 0 < a + 1
⊢ 0 < 1 + a

tactic: assumption
state_before: a : ℕ
this : 0 < a + 1
⊢ 0 < a + 1
Theorem: MeasureTheory.SimpleFunc.const_lintegral_restrict
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: rw [const_lintegral, Measure.restrict_apply MeasurableSet.univ, univ_inter]
state_before: α : Type u_1
β : Type ?u.897125
γ : Type ?u.897128
δ : Type ?u.897131
m : MeasurableSpace α
μ ν : Measure α
c : ℝ≥0∞
s : Set α
⊢ lintegral (const α c) (Measure.restrict μ s) = c * ↑↑μ s
Theorem: ENNReal.mul_rpow_of_nonneg
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: simp [hz.not_lt, mul_rpow_eq_ite]
state_before: x y : ℝ≥0∞
z : ℝ
hz : 0 ≤ z
⊢ (x * y) ^ z = x ^ z * y ^ z
Theorem: CircleDeg1Lift.units_semiconj_of_translationNumber_eq
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simp [h]
state_before: f g : CircleDeg1Lift
f₁ f₂ : CircleDeg1Liftˣ
h : τ ↑f₁ = τ ↑f₂
n : Multiplicative ℤ
⊢ τ (↑(MonoidHom.comp (Units.coeHom CircleDeg1Lift) (↑(zpowersHom CircleDeg1Liftˣ) f₁)) n) =
    τ (↑(MonoidHom.comp (Units.coeHom CircleDeg1Lift) (↑(zpowersHom CircleDeg1Liftˣ) f₂)) n)

tactic: simpa using hF (Multiplicative.ofAdd 1)
state_before: f g : CircleDeg1Lift
f₁ f₂ : CircleDeg1Liftˣ
h : τ ↑f₁ = τ ↑f₂
this :
  ∀ (n : Multiplicative ℤ),
    τ (↑(MonoidHom.comp (Units.coeHom CircleDeg1Lift) (↑(zpowersHom CircleDeg1Liftˣ) f₁)) n) =
      τ (↑(MonoidHom.comp (Units.coeHom CircleDeg1Lift) (↑(zpowersHom CircleDeg1Liftˣ) f₂)) n)
F : CircleDeg1Lift
hF :
  ∀ (g : Multiplicative ℤ),
    Semiconj ↑F ↑(↑(MonoidHom.comp (Units.coeHom CircleDeg1Lift) (↑(zpowersHom CircleDeg1Liftˣ) f₁)) g)
      ↑(↑(MonoidHom.comp (Units.coeHom CircleDeg1Lift) (↑(zpowersHom CircleDeg1Liftˣ) f₂)) g)
⊢ Semiconj ↑F ↑↑f₁ ↑↑f₂
Theorem: infEdist_inv_inv
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: rw [← image_inv, infEdist_image isometry_inv]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s✝ t : Set E
x✝ y x : E
s : Set E
⊢ infEdist x⁻¹ s⁻¹ = infEdist x s
Theorem: multiplicity.is_greatest
File: Mathlib/RingTheory/Multiplicity.lean

tactic: rw [PartENat.lt_coe_iff] at hm
state_before: α : Type u_1
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
m : ℕ
hm : multiplicity a b < ↑m
h : a ^ m ∣ b
⊢ False

tactic: exact Nat.find_spec hm.fst ((pow_dvd_pow _ hm.snd).trans h)
state_before: α : Type u_1
inst✝¹ : Monoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
m : ℕ
hm : ∃ h, Part.get (multiplicity a b) h < m
h : a ^ m ∣ b
⊢ False
Theorem: MeasureTheory.exists_measurableEmbedding_real
File: Mathlib/MeasureTheory/Constructions/Polish.lean

tactic: obtain ⟨s, hs, ⟨e⟩⟩ := exists_subset_real_measurableEquiv α
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.401587
inst✝² : MeasurableSpace α
inst✝¹ : PolishSpace α
inst✝ : BorelSpace α
⊢ ∃ f, MeasurableEmbedding f

tactic: exact ⟨(↑) ∘ e, (MeasurableEmbedding.subtype_coe hs).comp e.measurableEmbedding⟩
state_before: case intro.intro.intro
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.401587
inst✝² : MeasurableSpace α
inst✝¹ : PolishSpace α
inst✝ : BorelSpace α
s : Set ℝ
hs : MeasurableSet s
e : α ≃ᵐ ↑s
⊢ ∃ f, MeasurableEmbedding f
Theorem: BooleanRing.sup_assoc
File: Mathlib/Algebra/Ring/BooleanRing.lean

tactic: ring
state_before: α : Type u_1
β : Type ?u.13321
γ : Type ?u.13324
inst✝² : BooleanRing α
inst✝¹ : BooleanRing β
inst✝ : BooleanRing γ
a b c : α
⊢ a + b + a * b + c + (a + b + a * b) * c = a + (b + c + b * c) + a * (b + c + b * c)
Theorem: PadicInt.coe_eq_zero
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: rw [← coe_zero, Subtype.coe_inj]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
z : ℤ_[p]
⊢ ↑z = 0 ↔ z = 0
Theorem: Polynomial.natTrailingDegree_eq_of_trailingDegree_eq
File: Mathlib/Data/Polynomial/Degree/TrailingDegree.lean

tactic: unfold natTrailingDegree
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝¹ : Semiring R
p q✝ r : R[X]
inst✝ : Semiring S
q : S[X]
h : trailingDegree p = trailingDegree q
⊢ natTrailingDegree p = natTrailingDegree q

tactic: rw [h]
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝¹ : Semiring R
p q✝ r : R[X]
inst✝ : Semiring S
q : S[X]
h : trailingDegree p = trailingDegree q
⊢ Option.getD (trailingDegree p) 0 = Option.getD (trailingDegree q) 0
Theorem: AntilipschitzWith.id
File: Mathlib/Topology/MetricSpace/Antilipschitz.lean

tactic: simp only [ENNReal.coe_one, one_mul, id, le_refl]
state_before: α : Type u_1
β : Type ?u.6535
γ : Type ?u.6538
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K : ℝ≥0
f : α → β
x y : α
⊢ edist x y ≤ ↑1 * edist (id x) (id y)
Theorem: UpperSet.coe_iInf₂
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp_rw [coe_iInf]
state_before: α : Type u_1
β : Type ?u.57093
γ : Type ?u.57096
ι : Sort u_2
κ : ι → Sort u_3
inst✝ : LE α
S : Set (UpperSet α)
s t : UpperSet α
a : α
f : (i : ι) → κ i → UpperSet α
⊢ ↑(⨅ (i : ι) (j : κ i), f i j) = ⋃ (i : ι) (j : κ i), ↑(f i j)
Theorem: CategoryTheory.preservesColimitsIso_inv_comp_desc
File: Mathlib/CategoryTheory/Limits/Preserves/Limits.lean

tactic: ext
state_before: C : Type u₁
inst✝⁵ : Category C
D : Type u₂
inst✝⁴ : Category D
G : C ⥤ D
J : Type w
inst✝³ : Category J
F : J ⥤ C
inst✝² : PreservesColimit F G
inst✝¹ : HasColimit F
inst✝ : HasColimit (F ⋙ G)
t : Cocone F
⊢ (preservesColimitIso G F).inv ≫ G.map (colimit.desc F t) = colimit.desc (F ⋙ G) (G.mapCocone t)

tactic: simp [← G.map_comp]
state_before: case w
C : Type u₁
inst✝⁵ : Category C
D : Type u₂
inst✝⁴ : Category D
G : C ⥤ D
J : Type w
inst✝³ : Category J
F : J ⥤ C
inst✝² : PreservesColimit F G
inst✝¹ : HasColimit F
inst✝ : HasColimit (F ⋙ G)
t : Cocone F
j✝ : J
⊢ colimit.ι (F ⋙ G) j✝ ≫ (preservesColimitIso G F).inv ≫ G.map (colimit.desc F t) =
    colimit.ι (F ⋙ G) j✝ ≫ colimit.desc (F ⋙ G) (G.mapCocone t)
Theorem: Rat.divInt_zero_one
File: Mathlib/Data/Rat/Defs.lean

tactic: rw [divInt]
state_before: a b c : ℚ
⊢ 0 /. 1 = 0

tactic: simp
state_before: a b c : ℚ
⊢ (match 0, 1 with
    | n, Int.ofNat d => inline (mkRat n d)
    | n, Int.negSucc d => normalize (-n) (Nat.succ d)) =
    0
Theorem: ContinuousMap.preimage_gen
File: Mathlib/Topology/CompactOpen.lean

tactic: ext ⟨f, _⟩
state_before: α : Type u_1
β : Type u_3
γ : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
g : C(β, γ)
s : Set α
x✝¹ : IsCompact s
u : Set γ
x✝ : IsOpen u
⊢ comp g ⁻¹' CompactOpen.gen s u = CompactOpen.gen s (↑g ⁻¹' u)

tactic: change g ∘ f '' s ⊆ u ↔ f '' s ⊆ g ⁻¹' u
state_before: case h.mk
α : Type u_1
β : Type u_3
γ : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
g : C(β, γ)
s : Set α
x✝¹ : IsCompact s
u : Set γ
x✝ : IsOpen u
f : α → β
continuous_toFun✝ : Continuous f
⊢ mk f ∈ comp g ⁻¹' CompactOpen.gen s u ↔ mk f ∈ CompactOpen.gen s (↑g ⁻¹' u)

tactic: rw [image_comp, image_subset_iff]
state_before: case h.mk
α : Type u_1
β : Type u_3
γ : Type u_2
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ
g : C(β, γ)
s : Set α
x✝¹ : IsCompact s
u : Set γ
x✝ : IsOpen u
f : α → β
continuous_toFun✝ : Continuous f
⊢ ↑g ∘ f '' s ⊆ u ↔ f '' s ⊆ ↑g ⁻¹' u
Theorem: CategoryTheory.composePath_comp
File: Mathlib/CategoryTheory/PathCategory.lean

tactic: induction' g with Y' Z' g e ih
state_before: C : Type u₁
inst✝ : Category C
X Y Z : C
f : Path X Y
g : Path Y Z
⊢ composePath (Path.comp f g) = composePath f ≫ composePath g

tactic: simp
state_before: case nil
C : Type u₁
inst✝ : Category C
X Y Z : C
f : Path X Y
⊢ composePath (Path.comp f Path.nil) = composePath f ≫ composePath Path.nil

tactic: simp [ih]
state_before: case cons
C : Type u₁
inst✝ : Category C
X Y Z : C
f : Path X Y
Y' Z' : C
g : Path Y Y'
e : Y' ⟶ Z'
ih : composePath (Path.comp f g) = composePath f ≫ composePath g
⊢ composePath (Path.comp f (Path.cons g e)) = composePath f ≫ composePath (Path.cons g e)
Theorem: Cardinal.lift_down
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← lift_id (#β), ← lift_umax, ← lift_umax.{u, v}, lift_mk_le.{_,_,v}]
state_before: α✝ β✝ : Type u
a : Cardinal
b : Cardinal
α : Type u
β : Type (max u v)
⊢ (#β) ≤ lift (#α) → ∃ a', lift a' = (#β)

tactic: exact fun ⟨f⟩ =>
  ⟨#Set.range f,
    Eq.symm <| lift_mk_eq.{_, _, v}.2
      ⟨Function.Embedding.equivOfSurjective (Embedding.codRestrict _ f Set.mem_range_self)
          fun ⟨a, ⟨b, e⟩⟩ => ⟨b, Subtype.eq e⟩⟩⟩
state_before: α✝ β✝ : Type u
a : Cardinal
b : Cardinal
α : Type u
β : Type (max u v)
⊢ Nonempty (β ↪ α) → ∃ a', lift a' = lift (#β)
Theorem: Set.singleton_unop_op
File: Mathlib/Data/Set/Opposite.lean

tactic: ext
state_before: α : Type u_1
x : αᵒᵖ
⊢ Set.op {x.unop} = {x}

tactic: constructor
state_before: case h
α : Type u_1
x x✝ : αᵒᵖ
⊢ x✝ ∈ Set.op {x.unop} ↔ x✝ ∈ {x}

tactic: . apply unop_injective
state_before: case h.mp
α : Type u_1
x x✝ : αᵒᵖ
⊢ x✝ ∈ Set.op {x.unop} → x✝ ∈ {x}

case h.mpr
α : Type u_1
x x✝ : αᵒᵖ
⊢ x✝ ∈ {x} → x✝ ∈ Set.op {x.unop}

tactic: . apply op_injective
state_before: case h.mpr
α : Type u_1
x x✝ : αᵒᵖ
⊢ x✝ ∈ {x} → x✝ ∈ Set.op {x.unop}

tactic: apply unop_injective
state_before: case h.mp
α : Type u_1
x x✝ : αᵒᵖ
⊢ x✝ ∈ Set.op {x.unop} → x✝ ∈ {x}

tactic: apply op_injective
state_before: case h.mpr
α : Type u_1
x x✝ : αᵒᵖ
⊢ x✝ ∈ {x} → x✝ ∈ Set.op {x.unop}
Theorem: PNat.XgcdType.flip_v
File: Mathlib/Data/PNat/Xgcd.lean

tactic: dsimp [v]
state_before: u : XgcdType
⊢ v (flip u) = Prod.swap (v u)

tactic: ext
state_before: u : XgcdType
⊢ (↑(z u) * ↑(b u) + u.y * ↑(a u), u.x * ↑(b u) + ↑(w u) * ↑(a u)) =
    (u.y * ↑(a u) + ↑(z u) * ↑(b u), ↑(w u) * ↑(a u) + u.x * ↑(b u))

tactic: simp only
state_before: case h₁
u : XgcdType
⊢ (↑(z u) * ↑(b u) + u.y * ↑(a u), u.x * ↑(b u) + ↑(w u) * ↑(a u)).fst =
    (u.y * ↑(a u) + ↑(z u) * ↑(b u), ↑(w u) * ↑(a u) + u.x * ↑(b u)).fst

tactic: ring
state_before: case h₁
u : XgcdType
⊢ ↑(z u) * ↑(b u) + u.y * ↑(a u) = u.y * ↑(a u) + ↑(z u) * ↑(b u)

tactic: simp only
state_before: case h₂
u : XgcdType
⊢ (↑(z u) * ↑(b u) + u.y * ↑(a u), u.x * ↑(b u) + ↑(w u) * ↑(a u)).snd =
    (u.y * ↑(a u) + ↑(z u) * ↑(b u), ↑(w u) * ↑(a u) + u.x * ↑(b u)).snd

tactic: ring
state_before: case h₂
u : XgcdType
⊢ u.x * ↑(b u) + ↑(w u) * ↑(a u) = ↑(w u) * ↑(a u) + u.x * ↑(b u)
Theorem: CategoryTheory.Limits.Types.isLimitEquivSections_symm_apply
File: Mathlib/CategoryTheory/Limits/Types.lean

tactic: obtain ⟨x, rfl⟩ := (isLimitEquivSections.{v, u} t).surjective x
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TypeMax
c : Cone F
t : IsLimit c
x : ↑(Functor.sections F)
j : J
⊢ c.π.app j (↑(isLimitEquivSections t).symm x) = ↑x j

tactic: simp
state_before: case intro
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TypeMax
c : Cone F
t : IsLimit c
j : J
x : c.pt
⊢ c.π.app j (↑(isLimitEquivSections t).symm (↑(isLimitEquivSections t) x)) = ↑(↑(isLimitEquivSections t) x) j
Theorem: ContinuousMap.dist_le
File: Mathlib/Topology/ContinuousFunction/Compact.lean

tactic: simp only [← dist_mkOfCompact, BoundedContinuousFunction.dist_le C0, mkOfCompact_apply]
state_before: α : Type u_1
β : Type u_2
E : Type ?u.72363
inst✝³ : TopologicalSpace α
inst✝² : CompactSpace α
inst✝¹ : MetricSpace β
inst✝ : NormedAddCommGroup E
f g : C(α, β)
C : ℝ
C0 : 0 ≤ C
⊢ dist f g ≤ C ↔ ∀ (x : α), dist (↑f x) (↑g x) ≤ C
Theorem: EReal.bot_mul_of_pos
File: Mathlib/Data/Real/EReal.lean

tactic: rw [EReal.mul_comm]
state_before: x : EReal
h : 0 < x
⊢ ⊥ * x = ⊥

tactic: exact mul_bot_of_pos h
state_before: x : EReal
h : 0 < x
⊢ x * ⊥ = ⊥
Theorem: MeasureTheory.ae_withDensity_iff
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [ae_iff, ae_iff, withDensity_apply_eq_zero hf, iff_iff_eq]
state_before: α : Type u_1
β : Type ?u.1776303
γ : Type ?u.1776306
δ : Type ?u.1776309
m : MeasurableSpace α
μ ν : Measure α
p : α → Prop
f : α → ℝ≥0∞
hf : Measurable f
⊢ (∀ᵐ (x : α) ∂withDensity μ f, p x) ↔ ∀ᵐ (x : α) ∂μ, f x ≠ 0 → p x

tactic: congr
state_before: α : Type u_1
β : Type ?u.1776303
γ : Type ?u.1776306
δ : Type ?u.1776309
m : MeasurableSpace α
μ ν : Measure α
p : α → Prop
f : α → ℝ≥0∞
hf : Measurable f
⊢ (↑↑μ ({x | f x ≠ 0} ∩ {a | ¬p a}) = 0) = (↑↑μ {a | ¬(f a ≠ 0 → p a)} = 0)

tactic: ext x
state_before: case e_a.e_a
α : Type u_1
β : Type ?u.1776303
γ : Type ?u.1776306
δ : Type ?u.1776309
m : MeasurableSpace α
μ ν : Measure α
p : α → Prop
f : α → ℝ≥0∞
hf : Measurable f
⊢ {x | f x ≠ 0} ∩ {a | ¬p a} = {a | ¬(f a ≠ 0 → p a)}

tactic: simp only [exists_prop, mem_inter_iff, iff_self_iff, mem_setOf_eq, not_forall]
state_before: case e_a.e_a.h
α : Type u_1
β : Type ?u.1776303
γ : Type ?u.1776306
δ : Type ?u.1776309
m : MeasurableSpace α
μ ν : Measure α
p : α → Prop
f : α → ℝ≥0∞
hf : Measurable f
x : α
⊢ x ∈ {x | f x ≠ 0} ∩ {a | ¬p a} ↔ x ∈ {a | ¬(f a ≠ 0 → p a)}
Theorem: hasStrictDerivAt_pow
File: Mathlib/Analysis/Calculus/Deriv/Pow.lean

tactic: simp [hasStrictDerivAt_const]
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x✝ : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
c : 𝕜 → 𝕜
c' : 𝕜
n : ℕ
x : 𝕜
⊢ HasStrictDerivAt (fun x => x ^ 0) (↑0 * x ^ (0 - 1)) x

tactic: simpa using hasStrictDerivAt_id x
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x✝ : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
c : 𝕜 → 𝕜
c' : 𝕜
n : ℕ
x : 𝕜
⊢ HasStrictDerivAt (fun x => x ^ 1) (↑1 * x ^ (1 - 1)) x

tactic: simpa [pow_succ', add_mul, mul_assoc] using
  (hasStrictDerivAt_pow (n + 1) x).mul (hasStrictDerivAt_id x)
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x✝ : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
c : 𝕜 → 𝕜
c' : 𝕜
n✝ n : ℕ
x : 𝕜
⊢ HasStrictDerivAt (fun x => x ^ (n + 1 + 1)) (↑(n + 1 + 1) * x ^ (n + 1 + 1 - 1)) x
Theorem: Acc.prod_gameAdd
File: Mathlib/Order/GameAdd.lean

tactic: induction' ha with a _ iha generalizing b
state_before: α : Type u_1
β : Type u_2
rα : α → α → Prop
rβ : β → β → Prop
a : α
b : β
ha : Acc rα a
hb : Acc rβ b
⊢ Acc (Prod.GameAdd rα rβ) (a, b)

tactic: induction' hb with b hb ihb
state_before: case intro
α : Type u_1
β : Type u_2
rα : α → α → Prop
rβ : β → β → Prop
a✝ : α
b✝ : β
hb✝ : Acc rβ b✝
a : α
h✝ : ∀ (y : α), rα y a → Acc rα y
iha : ∀ (y : α), rα y a → ∀ {b : β}, Acc rβ b → Acc (Prod.GameAdd rα rβ) (y, b)
b : β
hb : Acc rβ b
⊢ Acc (Prod.GameAdd rα rβ) (a, b)

tactic: refine' Acc.intro _ fun h => _
state_before: case intro.intro
α : Type u_1
β : Type u_2
rα : α → α → Prop
rβ : β → β → Prop
a✝ : α
b✝¹ : β
hb✝ : Acc rβ b✝¹
a : α
h✝ : ∀ (y : α), rα y a → Acc rα y
iha : ∀ (y : α), rα y a → ∀ {b : β}, Acc rβ b → Acc (Prod.GameAdd rα rβ) (y, b)
b✝ b : β
hb : ∀ (y : β), rβ y b → Acc rβ y
ihb : ∀ (y : β), rβ y b → Acc (Prod.GameAdd rα rβ) (a, y)
⊢ Acc (Prod.GameAdd rα rβ) (a, b)

tactic: rintro (⟨ra⟩ | ⟨rb⟩)
state_before: case intro.intro
α : Type u_1
β : Type u_2
rα : α → α → Prop
rβ : β → β → Prop
a✝ : α
b✝¹ : β
hb✝ : Acc rβ b✝¹
a : α
h✝ : ∀ (y : α), rα y a → Acc rα y
iha : ∀ (y : α), rα y a → ∀ {b : β}, Acc rβ b → Acc (Prod.GameAdd rα rβ) (y, b)
b✝ b : β
hb : ∀ (y : β), rβ y b → Acc rβ y
ihb : ∀ (y : β), rβ y b → Acc (Prod.GameAdd rα rβ) (a, y)
h : α × β
⊢ Prod.GameAdd rα rβ h (a, b) → Acc (Prod.GameAdd rα rβ) h

tactic: exacts [iha _ ra (Acc.intro b hb), ihb _ rb]
state_before: case intro.intro.fst
α : Type u_1
β : Type u_2
rα : α → α → Prop
rβ : β → β → Prop
a✝ : α
b✝¹ : β
hb✝ : Acc rβ b✝¹
a : α
h✝ : ∀ (y : α), rα y a → Acc rα y
iha : ∀ (y : α), rα y a → ∀ {b : β}, Acc rβ b → Acc (Prod.GameAdd rα rβ) (y, b)
b✝ b : β
hb : ∀ (y : β), rβ y b → Acc rβ y
ihb : ∀ (y : β), rβ y b → Acc (Prod.GameAdd rα rβ) (a, y)
a₁✝ : α
ra : rα a₁✝ a
⊢ Acc (Prod.GameAdd rα rβ) (a₁✝, b)

case intro.intro.snd
α : Type u_1
β : Type u_2
rα : α → α → Prop
rβ : β → β → Prop
a✝ : α
b✝¹ : β
hb✝ : Acc rβ b✝¹
a : α
h✝ : ∀ (y : α), rα y a → Acc rα y
iha : ∀ (y : α), rα y a → ∀ {b : β}, Acc rβ b → Acc (Prod.GameAdd rα rβ) (y, b)
b✝ b : β
hb : ∀ (y : β), rβ y b → Acc rβ y
ihb : ∀ (y : β), rβ y b → Acc (Prod.GameAdd rα rβ) (a, y)
b₁✝ : β
rb : rβ b₁✝ b
⊢ Acc (Prod.GameAdd rα rβ) (a, b₁✝)
Theorem: String.utf8Len_eq_zero
File: Std/Data/String/Lemmas.lean

tactic: cases l <;> simp [Nat.ne_of_gt add_csize_pos]
state_before: l : List Char
⊢ utf8Len l = 0 ↔ l = []
Theorem: MeasureTheory.continuousAt_of_dominated
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [integral, L1.integral]
state_before: α : Type u_2
E : Type u_3
F✝ : Type ?u.1019635
𝕜 : Type ?u.1019638
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace ℝ E
inst✝⁸ : CompleteSpace E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : SMulCommClass ℝ 𝕜 E
inst✝⁴ : NormedAddCommGroup F✝
inst✝³ : NormedSpace ℝ F✝
inst✝² : CompleteSpace F✝
f g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
F : X → α → E
x₀ : X
bound : α → ℝ
hF_meas : ∀ᶠ (x : X) in 𝓝 x₀, AEStronglyMeasurable (F x) μ
h_bound : ∀ᶠ (x : X) in 𝓝 x₀, ∀ᵐ (a : α) ∂μ, ‖F x a‖ ≤ bound a
bound_integrable : Integrable bound
h_cont : ∀ᵐ (a : α) ∂μ, ContinuousAt (fun x => F x a) x₀
⊢ ContinuousAt (fun x => ∫ (a : α), F x a ∂μ) x₀

tactic: exact continuousAt_setToFun_of_dominated (dominatedFinMeasAdditive_weightedSMul μ)
  hF_meas h_bound bound_integrable h_cont
state_before: α : Type u_2
E : Type u_3
F✝ : Type ?u.1019635
𝕜 : Type ?u.1019638
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace ℝ E
inst✝⁸ : CompleteSpace E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : SMulCommClass ℝ 𝕜 E
inst✝⁴ : NormedAddCommGroup F✝
inst✝³ : NormedSpace ℝ F✝
inst✝² : CompleteSpace F✝
f g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
F : X → α → E
x₀ : X
bound : α → ℝ
hF_meas : ∀ᶠ (x : X) in 𝓝 x₀, AEStronglyMeasurable (F x) μ
h_bound : ∀ᶠ (x : X) in 𝓝 x₀, ∀ᵐ (a : α) ∂μ, ‖F x a‖ ≤ bound a
bound_integrable : Integrable bound
h_cont : ∀ᵐ (a : α) ∂μ, ContinuousAt (fun x => F x a) x₀
⊢ ContinuousAt
    (fun x => if hf : Integrable fun a => F x a then ↑L1.integralCLM (Integrable.toL1 (fun a => F x a) hf) else 0) x₀