tasksource/leandojo huggingface dataset:
Theorem: SimpleGraph.Walk.IsPath.transfer
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p with
| nil => simp
| cons _ _ ih =>
  simp only [Walk.transfer, cons_isPath_iff, support_transfer _ ] at pp ⊢
  exact ⟨ih _ pp.1, pp.2⟩
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
hp : ∀ (e : Sym2 V), e ∈ edges p → e ∈ edgeSet H
pp : IsPath p
⊢ IsPath (Walk.transfer p H hp)

tactic: simp
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
u✝ : V
hp : ∀ (e : Sym2 V), e ∈ edges Walk.nil → e ∈ edgeSet H
pp : IsPath Walk.nil
⊢ IsPath (Walk.transfer Walk.nil H hp)

tactic: simp only [Walk.transfer, cons_isPath_iff, support_transfer _ ] at pp ⊢
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : ∀ (hp : ∀ (e : Sym2 V), e ∈ edges p✝ → e ∈ edgeSet H), IsPath p✝ → IsPath (Walk.transfer p✝ H hp)
hp : ∀ (e : Sym2 V), e ∈ edges (cons h✝ p✝) → e ∈ edgeSet H
pp : IsPath (cons h✝ p✝)
⊢ IsPath (Walk.transfer (cons h✝ p✝) H hp)

tactic: exact ⟨ih _ pp.1, pp.2⟩
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
H : SimpleGraph V
u✝ v✝ w✝ : V
h✝ : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : ∀ (hp : ∀ (e : Sym2 V), e ∈ edges p✝ → e ∈ edgeSet H), IsPath p✝ → IsPath (Walk.transfer p✝ H hp)
hp : ∀ (e : Sym2 V), e ∈ edges (cons h✝ p✝) → e ∈ edgeSet H
pp : IsPath p✝ ∧ ¬u✝ ∈ support p✝
⊢ IsPath (Walk.transfer p✝ H (_ : ∀ (e : Sym2 V), e ∈ edges p✝ → e ∈ edgeSet H)) ∧ ¬u✝ ∈ support p✝
Theorem: ENNReal.exists_nat_pos_mul_gt
File: Mathlib/Data/Real/ENNReal.lean

tactic: rwa [← ENNReal.div_lt_iff (Or.inl ha) (Or.inr hb)]
state_before: α : Type ?u.339781
β : Type ?u.339784
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ 0
hb : b ≠ ⊤
n : ℕ
hn : b / a < ↑n
⊢ b < ↑n * a
Theorem: Set.iUnion_iUnion_eq_or_left
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [iUnion_or, iUnion_union_distrib, iUnion_iUnion_eq_left]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.94012
ι : Sort ?u.94015
ι' : Sort ?u.94018
ι₂ : Sort ?u.94021
κ : ι → Sort ?u.94026
κ₁ : ι → Sort ?u.94031
κ₂ : ι → Sort ?u.94036
κ' : ι' → Sort ?u.94041
b : β
p : β → Prop
s : (x : β) → x = b ∨ p x → Set α
⊢ (⋃ (x : β) (h : x = b ∨ p x), s x h) = s b (_ : b = b ∨ p b) ∪ ⋃ (x : β) (h : p x), s x (_ : x = b ∨ p x)
Theorem: LipschitzWith.const_max
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

tactic: simpa only [max_comm] using hf.max_const a
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : PseudoEMetricSpace α
f g : α → ℝ
Kf Kg : ℝ≥0
hf : LipschitzWith Kf f
a : ℝ
⊢ LipschitzWith Kf fun x => max a (f x)
Theorem: Subsingleton.convexIndependent
File: Mathlib/Analysis/Convex/Independent.lean

tactic: intro s x hx
state_before: 𝕜 : Type u_2
E : Type u_3
ι : Type u_1
inst✝³ : OrderedSemiring 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
s t : Set E
inst✝ : Subsingleton ι
p : ι → E
⊢ ConvexIndependent 𝕜 p

tactic: have : (convexHull 𝕜 (p '' s)).Nonempty := ⟨p x, hx⟩
state_before: 𝕜 : Type u_2
E : Type u_3
ι : Type u_1
inst✝³ : OrderedSemiring 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
s✝ t : Set E
inst✝ : Subsingleton ι
p : ι → E
s : Set ι
x : ι
hx : p x ∈ ↑(convexHull 𝕜).toOrderHom (p '' s)
⊢ x ∈ s

tactic: rw [convexHull_nonempty_iff, Set.nonempty_image_iff] at this
state_before: 𝕜 : Type u_2
E : Type u_3
ι : Type u_1
inst✝³ : OrderedSemiring 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
s✝ t : Set E
inst✝ : Subsingleton ι
p : ι → E
s : Set ι
x : ι
hx : p x ∈ ↑(convexHull 𝕜).toOrderHom (p '' s)
this : Set.Nonempty (↑(convexHull 𝕜).toOrderHom (p '' s))
⊢ x ∈ s

tactic: rwa [Subsingleton.mem_iff_nonempty]
state_before: 𝕜 : Type u_2
E : Type u_3
ι : Type u_1
inst✝³ : OrderedSemiring 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
s✝ t : Set E
inst✝ : Subsingleton ι
p : ι → E
s : Set ι
x : ι
hx : p x ∈ ↑(convexHull 𝕜).toOrderHom (p '' s)
this : Set.Nonempty s
⊢ x ∈ s
Theorem: Set.one_mem_div_iff
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: simp [not_disjoint_iff_nonempty_inter, mem_div, div_eq_one, Set.Nonempty]
state_before: F : Type ?u.114914
α : Type u_1
β : Type ?u.114920
γ : Type ?u.114923
inst✝ : Group α
s t : Set α
a b : α
⊢ 1 ∈ s / t ↔ ¬Disjoint s t
Theorem: Matrix.comp_equiv_symm_dotProduct
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp only [Function.comp, Equiv.symm_apply_apply]
state_before: l : Type ?u.146320
m : Type u_1
n : Type u_2
o : Type ?u.146329
m' : o → Type ?u.146334
n' : o → Type ?u.146339
R : Type ?u.146342
S : Type ?u.146345
α : Type v
β : Type w
γ : Type ?u.146352
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
x y : n → α
e : m ≃ n
x✝¹ : m
x✝ : x✝¹ ∈ Finset.univ
⊢ (u ∘ ↑e.symm) (↑e x✝¹) * x (↑e x✝¹) = u x✝¹ * (x ∘ ↑e) x✝¹
Theorem: Nat.coprime_prod_left
File: Mathlib/Data/Nat/GCD/BigOperators.lean

tactic: simp
state_before: ι : Type u_1
x : ℕ
s : ι → ℕ
t : Finset ι
⊢ (fun y => coprime y x) 1
Theorem: IsClosed.measurableSet_image_of_continuousOn_injOn
File: Mathlib/MeasureTheory/Constructions/Polish.lean

tactic: rw [image_eq_range]
state_before: α : Type ?u.320629
inst✝⁵ : TopologicalSpace α
ι : Type ?u.320635
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
s : Set γ
hs : IsClosed s
f : γ → β
f_cont : ContinuousOn f s
f_inj : InjOn f s
⊢ MeasurableSet (f '' s)

tactic: haveI : PolishSpace s := IsClosed.polishSpace hs
state_before: α : Type ?u.320629
inst✝⁵ : TopologicalSpace α
ι : Type ?u.320635
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
s : Set γ
hs : IsClosed s
f : γ → β
f_cont : ContinuousOn f s
f_inj : InjOn f s
⊢ MeasurableSet (range fun x => f ↑x)

tactic: apply measurableSet_range_of_continuous_injective
state_before: α : Type ?u.320629
inst✝⁵ : TopologicalSpace α
ι : Type ?u.320635
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
s : Set γ
hs : IsClosed s
f : γ → β
f_cont : ContinuousOn f s
f_inj : InjOn f s
this : PolishSpace ↑s
⊢ MeasurableSet (range fun x => f ↑x)

tactic: rwa [continuousOn_iff_continuous_restrict] at f_cont
state_before: case f_cont
α : Type ?u.320629
inst✝⁵ : TopologicalSpace α
ι : Type ?u.320635
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
s : Set γ
hs : IsClosed s
f : γ → β
f_cont : ContinuousOn f s
f_inj : InjOn f s
this : PolishSpace ↑s
⊢ Continuous fun x => f ↑x

tactic: rwa [injOn_iff_injective] at f_inj
state_before: case f_inj
α : Type ?u.320629
inst✝⁵ : TopologicalSpace α
ι : Type ?u.320635
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
s : Set γ
hs : IsClosed s
f : γ → β
f_cont : ContinuousOn f s
f_inj : InjOn f s
this : PolishSpace ↑s
⊢ Injective fun x => f ↑x
Theorem: Ordinal.nadd_one
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: induction' a using Ordinal.induction with a IH
state_before: a b c : Ordinal
⊢ a ♯ 1 = succ a

tactic: rw [nadd_def, blsub_one, nadd_zero, max_eq_right_iff, blsub_le_iff]
state_before: case h
a✝ b c a : Ordinal
IH : ∀ (k : Ordinal), k < a → k ♯ 1 = succ k
⊢ a ♯ 1 = succ a

tactic: intro i hi
state_before: case h
a✝ b c a : Ordinal
IH : ∀ (k : Ordinal), k < a → k ♯ 1 = succ k
⊢ ∀ (i : Ordinal), i < a → i ♯ 1 < succ a

tactic: rwa [IH i hi, succ_lt_succ_iff]
state_before: case h
a✝ b c a : Ordinal
IH : ∀ (k : Ordinal), k < a → k ♯ 1 = succ k
i : Ordinal
hi : i < a
⊢ i ♯ 1 < succ a
Theorem: GroupCat.SurjectiveOfEpiAuxs.one_smul
File: Mathlib/Algebra/Category/GroupCat/EpiMono.lean

tactic: change fromCoset _ = fromCoset _
state_before: A B : GroupCat
f : A ⟶ B
x : X'
y : ↑(Set.range (Function.swap leftCoset (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier))
⊢ 1 • fromCoset y = fromCoset y

tactic: simp only [one_leftCoset, Subtype.ext_iff_val]
state_before: A B : GroupCat
f : A ⟶ B
x : X'
y : ↑(Set.range (Function.swap leftCoset (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier))
⊢ fromCoset
      { val := 1 *l ↑y,
        property :=
          (_ : 1 *l ↑y ∈ Set.range (Function.swap leftCoset (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier)) } =
    fromCoset y
Theorem: PGame.zero_lf
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [lf_def]
state_before: x : PGame
⊢ 0 ⧏ x ↔ ∃ i, ∀ (j : RightMoves (moveLeft x i)), 0 ⧏ moveRight (moveLeft x i) j

tactic: simp
state_before: x : PGame
⊢ ((∃ i,
        (∀ (i' : LeftMoves 0), moveLeft 0 i' ⧏ moveLeft x i) ∧
          ∀ (j : RightMoves (moveLeft x i)), 0 ⧏ moveRight (moveLeft x i) j) ∨
      ∃ j,
        (∀ (i : LeftMoves (moveRight 0 j)), moveLeft (moveRight 0 j) i ⧏ x) ∧
          ∀ (j' : RightMoves x), moveRight 0 j ⧏ moveRight x j') ↔
    ∃ i, ∀ (j : RightMoves (moveLeft x i)), 0 ⧏ moveRight (moveLeft x i) j
Theorem: ContDiffWithinAt.differentiableWithinAt_iteratedDerivWithin
File: Mathlib/Analysis/Calculus/IteratedDeriv.lean

tactic: simpa only [iteratedDerivWithin_eq_equiv_comp,
  LinearIsometryEquiv.comp_differentiableWithinAt_iff] using
  h.differentiableWithinAt_iteratedFDerivWithin hmn hs
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.53911
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n✝ : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
n : ℕ∞
m : ℕ
h : ContDiffWithinAt 𝕜 n f s x
hmn : ↑m < n
hs : UniqueDiffOn 𝕜 (insert x s)
⊢ DifferentiableWithinAt 𝕜 (iteratedDerivWithin m f s) s x
Theorem: MulLECancellable.mul_le_mul_iff_right
File: Mathlib/Algebra/Order/Monoid/Lemmas.lean

tactic: rw [mul_comm b, mul_comm c, ha.mul_le_mul_iff_left]
state_before: α : Type u_1
β : Type ?u.86235
inst✝² : LE α
inst✝¹ : CommSemigroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
ha : MulLECancellable a
⊢ b * a ≤ c * a ↔ b ≤ c
Theorem: CategoryTheory.Sieve.functorPushforward_comp
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: ext
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
S R✝ : Sieve X
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Sieve X
⊢ functorPushforward (F ⋙ G) R = functorPushforward G (functorPushforward F R)

tactic: simp [R.arrows.functorPushforward_comp F G]
state_before: case h
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
S R✝ : Sieve X
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Sieve X
Y✝ : E
f✝ : Y✝ ⟶ (F ⋙ G).obj X
⊢ (functorPushforward (F ⋙ G) R).arrows f✝ ↔ (functorPushforward G (functorPushforward F R)).arrows f✝
Theorem: Finmap.erase_union_singleton
File: Mathlib/Data/Finmap.lean

tactic: by_cases h' : x = a
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s : Finmap β
h : lookup a s = some b
x : α
⊢ lookup x (erase a s ∪ singleton a b) = lookup x s

tactic: subst a
state_before: case pos
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s : Finmap β
h : lookup a s = some b
x : α
h' : x = a
⊢ lookup x (erase a s ∪ singleton a b) = lookup x s

tactic: rw [lookup_union_right not_mem_erase_self, lookup_singleton_eq, h]
state_before: case pos
α : Type u
β : α → Type v
inst✝ : DecidableEq α
s : Finmap β
x : α
b : β x
h : lookup x s = some b
⊢ lookup x (erase x s ∪ singleton x b) = lookup x s

tactic: have : x ∉ singleton a b := by rwa [mem_singleton]
state_before: case neg
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s : Finmap β
h : lookup a s = some b
x : α
h' : ¬x = a
⊢ lookup x (erase a s ∪ singleton a b) = lookup x s

tactic: rw [lookup_union_left_of_not_in this, lookup_erase_ne h']
state_before: case neg
α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s : Finmap β
h : lookup a s = some b
x : α
h' : ¬x = a
this : ¬x ∈ singleton a b
⊢ lookup x (erase a s ∪ singleton a b) = lookup x s

tactic: rwa [mem_singleton]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s : Finmap β
h : lookup a s = some b
x : α
h' : ¬x = a
⊢ ¬x ∈ singleton a b
Theorem: Quiver.SingleObj.listToPath_pathToList
File: Mathlib/Combinatorics/Quiver/SingleObj.lean

tactic: induction' p with y z p a ih
state_before: α : Type u_1
β : Type ?u.4805
γ : Type ?u.4808
x : SingleObj α
p : Path (star α) x
⊢ listToPath (pathToList p) = Path.cast (_ : star α = star α) (_ : x = star α) p

tactic: rfl
state_before: case nil
α : Type u_1
β : Type ?u.4805
γ : Type ?u.4808
x : SingleObj α
⊢ listToPath (pathToList Path.nil) = Path.cast (_ : star α = star α) (_ : star α = star α) Path.nil

tactic: dsimp at *
state_before: case cons
α : Type u_1
β : Type ?u.4805
γ : Type ?u.4808
x y z : SingleObj α
p : Path (star α) y
a : y ⟶ z
ih : listToPath (pathToList p) = Path.cast (_ : star α = star α) (_ : y = star α) p
⊢ listToPath (pathToList (Path.cons p a)) = Path.cast (_ : star α = star α) (_ : z = star α) (Path.cons p a)

tactic: rw [ih]
state_before: case cons
α : Type u_1
β : Type ?u.4805
γ : Type ?u.4808
x y z : SingleObj α
p : Path (star α) y
a : y ⟶ z
ih : listToPath (pathToList p) = p
⊢ Path.cons (listToPath (pathToList p)) a = Path.cons p a
Theorem: Int.fmod_self
File: Std/Data/Int/DivMod.lean

tactic: have := mul_fmod_left 1 a
state_before: a : Int
⊢ fmod a a = 0

tactic: rwa [Int.one_mul] at this
state_before: a : Int
this : fmod (1 * a) a = 0
⊢ fmod a a = 0
Theorem: Fin.isCycle_cycleRange
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: cases' i with i hi
state_before: n : ℕ
i : Fin (n + 1)
h0 : i ≠ 0
⊢ IsCycle (cycleRange i)

tactic: cases i
state_before: case mk
n i : ℕ
hi : i < n + 1
h0 : { val := i, isLt := hi } ≠ 0
⊢ IsCycle (cycleRange { val := i, isLt := hi })

tactic: exact isCycle_finRotate.extendDomain _
state_before: case mk.succ
n n✝ : ℕ
hi : Nat.succ n✝ < n + 1
h0 : { val := Nat.succ n✝, isLt := hi } ≠ 0
⊢ IsCycle (cycleRange { val := Nat.succ n✝, isLt := hi })

tactic: exact (h0 rfl).elim
state_before: case mk.zero
n : ℕ
hi : Nat.zero < n + 1
h0 : { val := Nat.zero, isLt := hi } ≠ 0
⊢ IsCycle (cycleRange { val := Nat.zero, isLt := hi })
Theorem: add_nsmul
File: Mathlib/Algebra/GroupPower/Basic.lean

tactic: induction m with
| zero => rw [Nat.zero_add, zero_nsmul, zero_add]
| succ m ih => rw [Nat.succ_add, Nat.succ_eq_add_one, succ_nsmul, ih, succ_nsmul, add_assoc]
state_before: α : Type ?u.9319
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
a : A
m n : ℕ
⊢ (m + n) • a = m • a + n • a

tactic: rw [Nat.zero_add, zero_nsmul, zero_add]
state_before: case zero
α : Type ?u.9319
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
a : A
n : ℕ
⊢ (Nat.zero + n) • a = Nat.zero • a + n • a

tactic: rw [Nat.succ_add, Nat.succ_eq_add_one, succ_nsmul, ih, succ_nsmul, add_assoc]
state_before: case succ
α : Type ?u.9319
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
a : A
n m : ℕ
ih : (m + n) • a = m • a + n • a
⊢ (Nat.succ m + n) • a = Nat.succ m • a + n • a
Theorem: Set.comp_mulIndicator
File: Mathlib/Algebra/IndicatorFunction.lean

tactic: convert s.apply_piecewise f (const α 1) (fun _ => h) (x := x) using 2
state_before: α : Type u_1
β : Type u_2
ι : Type ?u.16343
M : Type u_3
N : Type ?u.16349
inst✝² : One M
inst✝¹ : One N
s✝ t : Set α
f✝ g : α → M
a : α
h : M → β
f : α → M
s : Set α
x : α
inst✝ : DecidablePred fun x => x ∈ s
this : DecidablePred fun x => x ∈ s := Classical.decPred fun x => x ∈ s
⊢ h (mulIndicator s f x) = piecewise s (h ∘ f) (const α (h 1)) x
Theorem: FirstOrder.Language.BoundedFormula.castLE_rfl
File: Mathlib/ModelTheory/Syntax.lean

tactic: induction' φ with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 _ _ ih3
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.48561
P : Type ?u.48564
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.48592
n✝ n : ℕ
h : n ≤ n
φ : BoundedFormula L α n
⊢ castLE h φ = φ

tactic: rfl
state_before: case falsum
L : Language
L' : Language
M : Type w
N : Type ?u.48561
P : Type ?u.48564
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.48592
n✝¹ n : ℕ
h✝ : n ≤ n
n✝ : ℕ
h : n✝ ≤ n✝
⊢ castLE h falsum = falsum

tactic: simp [Fin.castLE_of_eq]
state_before: case equal
L : Language
L' : Language
M : Type w
N : Type ?u.48561
P : Type ?u.48564
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.48592
n✝¹ n : ℕ
h✝ : n ≤ n
n✝ : ℕ
t₁✝ t₂✝ : Term L (α ⊕ Fin n✝)
h : n✝ ≤ n✝
⊢ castLE h (equal t₁✝ t₂✝) = equal t₁✝ t₂✝

tactic: simp [Fin.castLE_of_eq]
state_before: case rel
L : Language
L' : Language
M : Type w
N : Type ?u.48561
P : Type ?u.48564
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.48592
n✝¹ n : ℕ
h✝ : n ≤ n
n✝ l✝ : ℕ
R✝ : Relations L l✝
ts✝ : Fin l✝ → Term L (α ⊕ Fin n✝)
h : n✝ ≤ n✝
⊢ castLE h (rel R✝ ts✝) = rel R✝ ts✝

tactic: simp [Fin.castLE_of_eq, ih1, ih2]
state_before: case imp
L : Language
L' : Language
M : Type w
N : Type ?u.48561
P : Type ?u.48564
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.48592
n✝¹ n : ℕ
h✝ : n ≤ n
n✝ : ℕ
f₁✝ f₂✝ : BoundedFormula L α n✝
ih1 : ∀ (h : n✝ ≤ n✝), castLE h f₁✝ = f₁✝
ih2 : ∀ (h : n✝ ≤ n✝), castLE h f₂✝ = f₂✝
h : n✝ ≤ n✝
⊢ castLE h (imp f₁✝ f₂✝) = imp f₁✝ f₂✝

tactic: simp [Fin.castLE_of_eq, ih3]
state_before: case all
L : Language
L' : Language
M : Type w
N : Type ?u.48561
P : Type ?u.48564
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.48592
n✝¹ n : ℕ
h✝ : n ≤ n
n✝ : ℕ
f✝ : BoundedFormula L α (n✝ + 1)
ih3 : ∀ (h : n✝ + 1 ≤ n✝ + 1), castLE h f✝ = f✝
h : n✝ ≤ n✝
⊢ castLE h (all f✝) = all f✝
Theorem: MeasureTheory.SimpleFunc.le_sup_lintegral
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: rw [map_lintegral, map_lintegral]
state_before: α : Type u_1
β : Type ?u.897639
γ : Type ?u.897642
δ : Type ?u.897645
m : MeasurableSpace α
μ ν : Measure α
f g : α →ₛ ℝ≥0∞
⊢ lintegral (map Prod.fst (pair f g)) μ ⊔ lintegral (map Prod.snd (pair f g)) μ ≤
    ∑ x in SimpleFunc.range (pair f g), (x.fst ⊔ x.snd) * ↑↑μ (↑(pair f g) ⁻¹' {x})

tactic: refine' sup_le _ _ <;> refine' Finset.sum_le_sum fun a _ => mul_le_mul_right' _ _
state_before: α : Type u_1
β : Type ?u.897639
γ : Type ?u.897642
δ : Type ?u.897645
m : MeasurableSpace α
μ ν : Measure α
f g : α →ₛ ℝ≥0∞
⊢ (∑ x in SimpleFunc.range (pair f g), x.fst * ↑↑μ (↑(pair f g) ⁻¹' {x})) ⊔
      ∑ x in SimpleFunc.range (pair f g), x.snd * ↑↑μ (↑(pair f g) ⁻¹' {x}) ≤
    ∑ x in SimpleFunc.range (pair f g), (x.fst ⊔ x.snd) * ↑↑μ (↑(pair f g) ⁻¹' {x})

tactic: exact le_sup_left
state_before: case refine'_1
α : Type u_1
β : Type ?u.897639
γ : Type ?u.897642
δ : Type ?u.897645
m : MeasurableSpace α
μ ν : Measure α
f g : α →ₛ ℝ≥0∞
a : ℝ≥0∞ × ℝ≥0∞
x✝ : a ∈ SimpleFunc.range (pair f g)
⊢ a.fst ≤ a.fst ⊔ a.snd

case refine'_2
α : Type u_1
β : Type ?u.897639
γ : Type ?u.897642
δ : Type ?u.897645
m : MeasurableSpace α
μ ν : Measure α
f g : α →ₛ ℝ≥0∞
a : ℝ≥0∞ × ℝ≥0∞
x✝ : a ∈ SimpleFunc.range (pair f g)
⊢ a.snd ≤ a.fst ⊔ a.snd

tactic: exact le_sup_right
state_before: case refine'_2
α : Type u_1
β : Type ?u.897639
γ : Type ?u.897642
δ : Type ?u.897645
m : MeasurableSpace α
μ ν : Measure α
f g : α →ₛ ℝ≥0∞
a : ℝ≥0∞ × ℝ≥0∞
x✝ : a ∈ SimpleFunc.range (pair f g)
⊢ a.snd ≤ a.fst ⊔ a.snd

tactic: rw [sup_eq_map₂, map_lintegral]
state_before: α : Type u_1
β : Type ?u.897639
γ : Type ?u.897642
δ : Type ?u.897645
m : MeasurableSpace α
μ ν : Measure α
f g : α →ₛ ℝ≥0∞
⊢ ∑ x in SimpleFunc.range (pair f g), (x.fst ⊔ x.snd) * ↑↑μ (↑(pair f g) ⁻¹' {x}) = lintegral (f ⊔ g) μ
Theorem: aeSeq.measure_compl_aeSeqSet_eq_zero
File: Mathlib/MeasureTheory/Function/AEMeasurableSequence.lean

tactic: rw [aeSeqSet, compl_compl, measure_toMeasurable]
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type ?u.519115
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSpace β
f : ι → α → β
μ : MeasureTheory.Measure α
p : α → (ι → β) → Prop
inst✝ : Countable ι
hf : ∀ (i : ι), AEMeasurable (f i)
hp : ∀ᵐ (x : α) ∂μ, p x fun n => f n x
⊢ ↑↑μ (aeSeqSet hf pᶜ) = 0

tactic: have hf_eq := fun i => (hf i).ae_eq_mk
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type ?u.519115
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSpace β
f : ι → α → β
μ : MeasureTheory.Measure α
p : α → (ι → β) → Prop
inst✝ : Countable ι
hf : ∀ (i : ι), AEMeasurable (f i)
hp : ∀ᵐ (x : α) ∂μ, p x fun n => f n x
⊢ ↑↑μ ({x | (∀ (i : ι), f i x = AEMeasurable.mk (f i) (_ : AEMeasurable (f i)) x) ∧ p x fun n => f n x}ᶜ) = 0

tactic: simp_rw [Filter.EventuallyEq, ← ae_all_iff] at hf_eq
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type ?u.519115
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSpace β
f : ι → α → β
μ : MeasureTheory.Measure α
p : α → (ι → β) → Prop
inst✝ : Countable ι
hf : ∀ (i : ι), AEMeasurable (f i)
hp : ∀ᵐ (x : α) ∂μ, p x fun n => f n x
hf_eq : ∀ (i : ι), f i =ᵐ[μ] AEMeasurable.mk (f i) (_ : AEMeasurable (f i))
⊢ ↑↑μ ({x | (∀ (i : ι), f i x = AEMeasurable.mk (f i) (_ : AEMeasurable (f i)) x) ∧ p x fun n => f n x}ᶜ) = 0

tactic: exact Filter.Eventually.and hf_eq hp
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type ?u.519115
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSpace β
f : ι → α → β
μ : MeasureTheory.Measure α
p : α → (ι → β) → Prop
inst✝ : Countable ι
hf : ∀ (i : ι), AEMeasurable (f i)
hp : ∀ᵐ (x : α) ∂μ, p x fun n => f n x
hf_eq : ∀ᵐ (a : α) ∂μ, ∀ (i : ι), f i a = AEMeasurable.mk (f i) (_ : AEMeasurable (f i)) a
⊢ ↑↑μ ({x | (∀ (i : ι), f i x = AEMeasurable.mk (f i) (_ : AEMeasurable (f i)) x) ∧ p x fun n => f n x}ᶜ) = 0
Theorem: MvPowerSeries.mul_inv_rev
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: by_cases h : constantCoeff σ k (φ * ψ) = 0
state_before: σ : Type u_1
R : Type ?u.1945318
k : Type u_2
inst✝ : Field k
φ ψ : MvPowerSeries σ k
⊢ (φ * ψ)⁻¹ = ψ⁻¹ * φ⁻¹

tactic: rw [inv_eq_zero.mpr h]
state_before: case pos
σ : Type u_1
R : Type ?u.1945318
k : Type u_2
inst✝ : Field k
φ ψ : MvPowerSeries σ k
h : ↑(constantCoeff σ k) (φ * ψ) = 0
⊢ (φ * ψ)⁻¹ = ψ⁻¹ * φ⁻¹

tactic: simp only [map_mul, mul_eq_zero] at h
state_before: case pos
σ : Type u_1
R : Type ?u.1945318
k : Type u_2
inst✝ : Field k
φ ψ : MvPowerSeries σ k
h : ↑(constantCoeff σ k) (φ * ψ) = 0
⊢ 0 = ψ⁻¹ * φ⁻¹

tactic: cases' h with h h <;> simp [inv_eq_zero.mpr h]
state_before: case pos
σ : Type u_1
R : Type ?u.1945318
k : Type u_2
inst✝ : Field k
φ ψ : MvPowerSeries σ k
h : ↑(constantCoeff σ k) φ = 0 ∨ ↑(constantCoeff σ k) ψ = 0
⊢ 0 = ψ⁻¹ * φ⁻¹

tactic: rw [MvPowerSeries.inv_eq_iff_mul_eq_one h]
state_before: case neg
σ : Type u_1
R : Type ?u.1945318
k : Type u_2
inst✝ : Field k
φ ψ : MvPowerSeries σ k
h : ¬↑(constantCoeff σ k) (φ * ψ) = 0
⊢ (φ * ψ)⁻¹ = ψ⁻¹ * φ⁻¹

tactic: simp only [not_or, map_mul, mul_eq_zero] at h
state_before: case neg
σ : Type u_1
R : Type ?u.1945318
k : Type u_2
inst✝ : Field k
φ ψ : MvPowerSeries σ k
h : ¬↑(constantCoeff σ k) (φ * ψ) = 0
⊢ ψ⁻¹ * φ⁻¹ * (φ * ψ) = 1

tactic: rw [← mul_assoc, mul_assoc _⁻¹, MvPowerSeries.inv_mul_cancel _ h.left, mul_one,
  MvPowerSeries.inv_mul_cancel _ h.right]
state_before: case neg
σ : Type u_1
R : Type ?u.1945318
k : Type u_2
inst✝ : Field k
φ ψ : MvPowerSeries σ k
h : ¬↑(constantCoeff σ k) φ = 0 ∧ ¬↑(constantCoeff σ k) ψ = 0
⊢ ψ⁻¹ * φ⁻¹ * (φ * ψ) = 1