tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.OuterMeasure.trim_iSup
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: simp_rw [← @iSup_plift_down _ ι]
state_before: α : Type u_2
inst✝¹ : MeasurableSpace α
m : OuterMeasure α
ι : Sort u_1
inst✝ : Countable ι
μ : ι → OuterMeasure α
⊢ trim (⨆ (i : ι), μ i) = ⨆ (i : ι), trim (μ i)

tactic: ext1 s
state_before: α : Type u_2
inst✝¹ : MeasurableSpace α
m : OuterMeasure α
ι : Sort u_1
inst✝ : Countable ι
μ : ι → OuterMeasure α
⊢ trim (⨆ (i : PLift ι), μ i.down) = ⨆ (i : PLift ι), trim (μ i.down)

tactic: haveI : Countable (Option <| PLift ι) := by exact instCountableOption
state_before: case h
α : Type u_2
inst✝¹ : MeasurableSpace α
m : OuterMeasure α
ι : Sort u_1
inst✝ : Countable ι
μ : ι → OuterMeasure α
s : Set α
⊢ ↑(trim (⨆ (i : PLift ι), μ i.down)) s = ↑(⨆ (i : PLift ι), trim (μ i.down)) s

tactic: obtain ⟨t, _, _, hμt⟩ :=
  exists_measurable_superset_forall_eq_trim
    (Option.elim' (⨆ i, μ (PLift.down i)) (μ ∘ PLift.down)) s
state_before: case h
α : Type u_2
inst✝¹ : MeasurableSpace α
m : OuterMeasure α
ι : Sort u_1
inst✝ : Countable ι
μ : ι → OuterMeasure α
s : Set α
this : Countable (Option (PLift ι))
⊢ ↑(trim (⨆ (i : PLift ι), μ i.down)) s = ↑(⨆ (i : PLift ι), trim (μ i.down)) s

tactic: simp only [Option.forall, Option.elim'] at hμt
state_before: case h.intro.intro.intro
α : Type u_2
inst✝¹ : MeasurableSpace α
m : OuterMeasure α
ι : Sort u_1
inst✝ : Countable ι
μ : ι → OuterMeasure α
s : Set α
this : Countable (Option (PLift ι))
t : Set α
left✝¹ : s ⊆ t
left✝ : MeasurableSet t
hμt :
  ∀ (i : Option (PLift ι)),
    ↑(Option.elim' (⨆ (i : PLift ι), μ i.down) (μ ∘ PLift.down) i) t =
      ↑(trim (Option.elim' (⨆ (i : PLift ι), μ i.down) (μ ∘ PLift.down) i)) s
⊢ ↑(trim (⨆ (i : PLift ι), μ i.down)) s = ↑(⨆ (i : PLift ι), trim (μ i.down)) s

tactic: simp only [iSup_apply, ← hμt.1]
state_before: case h.intro.intro.intro
α : Type u_2
inst✝¹ : MeasurableSpace α
m : OuterMeasure α
ι : Sort u_1
inst✝ : Countable ι
μ : ι → OuterMeasure α
s : Set α
this : Countable (Option (PLift ι))
t : Set α
left✝¹ : s ⊆ t
left✝ : MeasurableSet t
hμt :
  ↑(⨆ (i : PLift ι), μ i.down) t = ↑(trim (⨆ (i : PLift ι), μ i.down)) s ∧
    ∀ (x : PLift ι), ↑((μ ∘ PLift.down) x) t = ↑(trim ((μ ∘ PLift.down) x)) s
⊢ ↑(trim (⨆ (i : PLift ι), μ i.down)) s = ↑(⨆ (i : PLift ι), trim (μ i.down)) s

tactic: exact iSup_congr hμt.2
state_before: case h.intro.intro.intro
α : Type u_2
inst✝¹ : MeasurableSpace α
m : OuterMeasure α
ι : Sort u_1
inst✝ : Countable ι
μ : ι → OuterMeasure α
s : Set α
this : Countable (Option (PLift ι))
t : Set α
left✝¹ : s ⊆ t
left✝ : MeasurableSet t
hμt :
  ↑(⨆ (i : PLift ι), μ i.down) t = ↑(trim (⨆ (i : PLift ι), μ i.down)) s ∧
    ∀ (x : PLift ι), ↑((μ ∘ PLift.down) x) t = ↑(trim ((μ ∘ PLift.down) x)) s
⊢ (⨆ (i : PLift ι), ↑(μ i.down) t) = ⨆ (i : PLift ι), ↑(trim (μ i.down)) s

tactic: exact instCountableOption
state_before: α : Type u_2
inst✝¹ : MeasurableSpace α
m : OuterMeasure α
ι : Sort u_1
inst✝ : Countable ι
μ : ι → OuterMeasure α
s : Set α
⊢ Countable (Option (PLift ι))
Theorem: Fin.card_filter_univ_succ
File: Mathlib/Data/Fintype/Fin.lean

tactic: split_ifs <;> simp [add_comm 1]
state_before: α : Type ?u.16258
β : Type ?u.16261
n : ℕ
p : Fin (n + 1) → Prop
inst✝ : DecidablePred p
⊢ (if p 0 then 1 else 0) + Finset.card (filter (p ∘ succ) univ) =
    if p 0 then Finset.card (filter (p ∘ succ) univ) + 1 else Finset.card (filter (p ∘ succ) univ)
Theorem: minpoly.coeff_zero_eq_zero
File: Mathlib/FieldTheory/Minpoly/Field.lean

tactic: constructor
state_before: A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
⊢ coeff (minpoly A x) 0 = 0 ↔ x = 0

tactic: intro h
state_before: case mp
A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
⊢ coeff (minpoly A x) 0 = 0 → x = 0

tactic: have zero_root := zero_isRoot_of_coeff_zero_eq_zero h
state_before: case mp
A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
h : coeff (minpoly A x) 0 = 0
⊢ x = 0

tactic: rw [← root hx zero_root]
state_before: case mp
A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
h : coeff (minpoly A x) 0 = 0
zero_root : IsRoot (minpoly A x) 0
⊢ x = 0

tactic: exact RingHom.map_zero _
state_before: case mp
A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
h : coeff (minpoly A x) 0 = 0
zero_root : IsRoot (minpoly A x) 0
⊢ ↑(algebraMap A B) 0 = 0

tactic: rintro rfl
state_before: case mpr
A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
⊢ x = 0 → coeff (minpoly A x) 0 = 0

tactic: simp
state_before: case mpr
A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
hx : IsIntegral A 0
⊢ coeff (minpoly A 0) 0 = 0
Theorem: Submodule.mem_orthogonal_singleton_iff_inner_right
File: Mathlib/Analysis/InnerProductSpace/Orthogonal.lean

tactic: refine' ⟨inner_right_of_mem_orthogonal (mem_span_singleton_self u), _⟩
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.25024
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
u v : E
⊢ v ∈ (span 𝕜 {u})ᗮ ↔ inner u v = 0

tactic: intro hv w hw
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.25024
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
u v : E
⊢ inner u v = 0 → v ∈ (span 𝕜 {u})ᗮ

tactic: rw [mem_span_singleton] at hw
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.25024
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
u v : E
hv : inner u v = 0
w : E
hw : w ∈ span 𝕜 {u}
⊢ inner w v = 0

tactic: obtain ⟨c, rfl⟩ := hw
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.25024
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
u v : E
hv : inner u v = 0
w : E
hw : ∃ a, a • u = w
⊢ inner w v = 0

tactic: simp [inner_smul_left, hv]
state_before: case intro
𝕜 : Type u_2
E : Type u_1
F : Type ?u.25024
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
u v : E
hv : inner u v = 0
c : 𝕜
⊢ inner (c • u) v = 0
Theorem: SimpleGraph.Walk.mem_tail_support_append_iff
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: rw [tail_support_append, List.mem_append]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
t u v w : V
p : Walk G u v
p' : Walk G v w
⊢ t ∈ List.tail (support (append p p')) ↔ t ∈ List.tail (support p) ∨ t ∈ List.tail (support p')
Theorem: Dfinsupp.liftAddHom_comp_single
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: simp
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → AddZeroClass (β i)
inst✝ : AddCommMonoid γ
f : (i : ι) → β i →+ γ
i : ι
⊢ AddMonoidHom.comp (↑liftAddHom f) (singleAddHom β i) = f i
Theorem: dvd_antisymm
File: Mathlib/Algebra/GroupWithZero/Divisibility.lean

tactic: rintro ⟨c, rfl⟩ ⟨d, hcd⟩
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : Subsingleton αˣ
a b : α
⊢ a ∣ b → b ∣ a → a = b

tactic: rw [mul_assoc, eq_comm, mul_right_eq_self₀, mul_eq_one] at hcd
state_before: case intro.intro
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : Subsingleton αˣ
a c d : α
hcd : a = a * c * d
⊢ a = a * c

tactic: obtain ⟨rfl, -⟩ | rfl := hcd <;> simp
state_before: case intro.intro
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : Subsingleton αˣ
a c d : α
hcd : c = 1 ∧ d = 1 ∨ a = 0
⊢ a = a * c
Theorem: List.mapIdx_eq_enum_map
File: Mathlib/Data/List/Indexes.lean

tactic: rw [List.new_def_eq_old_def]
state_before: α : Type u
β : Type v
l : List α
f : ℕ → α → β
⊢ mapIdx f l = map (uncurry f) (enum l)

tactic: induction' l with hd tl hl generalizing f
state_before: α : Type u
β : Type v
l : List α
f : ℕ → α → β
⊢ List.oldMapIdx f l = map (uncurry f) (enum l)

tactic: rfl
state_before: case nil
α : Type u
β : Type v
f✝ f : ℕ → α → β
⊢ List.oldMapIdx f [] = map (uncurry f) (enum [])

tactic: rw [List.oldMapIdx, List.oldMapIdxCore, List.oldMapIdxCore_eq, hl]
state_before: case cons
α : Type u
β : Type v
f✝ : ℕ → α → β
hd : α
tl : List α
hl : ∀ (f : ℕ → α → β), List.oldMapIdx f tl = map (uncurry f) (enum tl)
f : ℕ → α → β
⊢ List.oldMapIdx f (hd :: tl) = map (uncurry f) (enum (hd :: tl))

tactic: simp [enum_eq_zip_range, map_uncurry_zip_eq_zipWith]
state_before: case cons
α : Type u
β : Type v
f✝ : ℕ → α → β
hd : α
tl : List α
hl : ∀ (f : ℕ → α → β), List.oldMapIdx f tl = map (uncurry f) (enum tl)
f : ℕ → α → β
⊢ f 0 hd :: map (uncurry fun i a => f (i + (0 + 1)) a) (enum tl) = map (uncurry f) (enum (hd :: tl))
Theorem: continuousWithinAt_inter'
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp [ContinuousWithinAt, nhdsWithin_restrict'' s h]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.321337
δ : Type ?u.321340
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s t : Set α
x : α
h : t ∈ 𝓝[s] x
⊢ ContinuousWithinAt f (s ∩ t) x ↔ ContinuousWithinAt f s x
Theorem: div_eq_self
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [div_eq_mul_inv, mul_right_eq_self, inv_eq_one]
state_before: α : Type ?u.61853
β : Type ?u.61856
G : Type u_1
inst✝ : Group G
a b c d : G
⊢ a / b = a ↔ b = 1
Theorem: List.perm_orderedInsert
File: Mathlib/Data/List/Sort.lean

tactic: by_cases h : a ≼ b
state_before: α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
a b : α
l : List α
⊢ orderedInsert r a (b :: l) ~ a :: b :: l

tactic: simp [orderedInsert, h]
state_before: case pos
α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
a b : α
l : List α
h : r a b
⊢ orderedInsert r a (b :: l) ~ a :: b :: l

tactic: simpa [orderedInsert, h] using ((perm_orderedInsert a l).cons _).trans (Perm.swap _ _ _)
state_before: case neg
α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
a b : α
l : List α
h : ¬r a b
⊢ orderedInsert r a (b :: l) ~ a :: b :: l
Theorem: ack_succ_right_le_ack_succ_left
File: Mathlib/Computability/Ackermann.lean

tactic: cases' n with n n
state_before: m n : ℕ
⊢ ack m (n + 1) ≤ ack (m + 1) n

tactic: simp
state_before: case zero
m : ℕ
⊢ ack m (zero + 1) ≤ ack (m + 1) zero

tactic: rw [ack_succ_succ, succ_eq_add_one]
state_before: case succ
m n : ℕ
⊢ ack m (succ n + 1) ≤ ack (m + 1) (succ n)

tactic: apply ack_mono_right m (le_trans _ <| add_add_one_le_ack _ n)
state_before: case succ
m n : ℕ
⊢ ack m (n + 1 + 1) ≤ ack m (ack (m + 1) n)

tactic: linarith
state_before: m n : ℕ
⊢ n + 1 + 1 ≤ m + 1 + n + 1
Theorem: cmp_compares
File: Mathlib/Order/Compare.lean

tactic: obtain h | h | h := lt_trichotomy a b <;> simp [cmp, cmpUsing, h, h.not_lt]
state_before: α : Type u_1
β : Type ?u.11521
inst✝ : LinearOrder α
a b : α
⊢ Compares (cmp a b) a b
Theorem: Multiset.inter_add_distrib
File: Mathlib/Data/Multiset/Basic.lean

tactic: by_contra h
state_before: α : Type u_1
β : Type ?u.188231
γ : Type ?u.188234
inst✝ : DecidableEq α
s✝ t✝ u✝ : Multiset α
a b : α
s t u : Multiset α
⊢ s ∩ t + u = (s + u) ∩ (t + u)

tactic: cases'
  lt_iff_cons_le.1
    (lt_of_le_of_ne
      (le_inter (add_le_add_right (inter_le_left s t) u)
        (add_le_add_right (inter_le_right s t) u))
      h) with
  a hl
state_before: α : Type u_1
β : Type ?u.188231
γ : Type ?u.188234
inst✝ : DecidableEq α
s✝ t✝ u✝ : Multiset α
a b : α
s t u : Multiset α
h : ¬s ∩ t + u = (s + u) ∩ (t + u)
⊢ False

tactic: rw [← cons_add] at hl
state_before: case intro
α : Type u_1
β : Type ?u.188231
γ : Type ?u.188234
inst✝ : DecidableEq α
s✝ t✝ u✝ : Multiset α
a✝ b : α
s t u : Multiset α
h : ¬s ∩ t + u = (s + u) ∩ (t + u)
a : α
hl : a ::ₘ (s ∩ t + u) ≤ (s + u) ∩ (t + u)
⊢ False

tactic: exact
  not_le_of_lt (lt_cons_self (s ∩ t) a)
    (le_inter (le_of_add_le_add_right (le_trans hl (inter_le_left _ _)))
      (le_of_add_le_add_right (le_trans hl (inter_le_right _ _))))
state_before: case intro
α : Type u_1
β : Type ?u.188231
γ : Type ?u.188234
inst✝ : DecidableEq α
s✝ t✝ u✝ : Multiset α
a✝ b : α
s t u : Multiset α
h : ¬s ∩ t + u = (s + u) ∩ (t + u)
a : α
hl : a ::ₘ s ∩ t + u ≤ (s + u) ∩ (t + u)
⊢ False
Theorem: bit0_injective
File: Mathlib/Algebra/CharZero/Lemmas.lean

tactic: dsimp [bit0] at h
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : NoZeroDivisors R
inst✝ : CharZero R
a b : R
h : bit0 a = bit0 b
⊢ a = b

tactic: simp only [(two_mul a).symm, (two_mul b).symm] at h
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : NoZeroDivisors R
inst✝ : CharZero R
a b : R
h : a + a = b + b
⊢ a = b

tactic: refine' nat_mul_inj' _ two_ne_zero
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : NoZeroDivisors R
inst✝ : CharZero R
a b : R
h : 2 * a = 2 * b
⊢ a = b

tactic: exact_mod_cast h
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : NoZeroDivisors R
inst✝ : CharZero R
a b : R
h : 2 * a = 2 * b
⊢ ↑2 * a = ↑2 * b
Theorem: Nat.shiftl'_tt_eq_mul_pow
File: Mathlib/Data/Nat/Size.lean

tactic: simp [shiftl, shiftl', pow_zero, Nat.one_mul]
state_before: m : ℕ
⊢ shiftl' true m 0 + 1 = (m + 1) * 2 ^ 0

tactic: change bit1 (shiftl' true m k) + 1 = (m + 1) * (2 ^ k * 2)
state_before: m k : ℕ
⊢ shiftl' true m (k + 1) + 1 = (m + 1) * 2 ^ (k + 1)

tactic: rw [bit1_val]
state_before: m k : ℕ
⊢ bit1 (shiftl' true m k) + 1 = (m + 1) * (2 ^ k * 2)

tactic: change 2 * (shiftl' true m k + 1) = _
state_before: m k : ℕ
⊢ 2 * shiftl' true m k + 1 + 1 = (m + 1) * (2 ^ k * 2)

tactic: rw [shiftl'_tt_eq_mul_pow m k, mul_left_comm, mul_comm 2]
state_before: m k : ℕ
⊢ 2 * (shiftl' true m k + 1) = (m + 1) * (2 ^ k * 2)
Theorem: Nat.odd_mod_four_iff
File: Mathlib/Data/Nat/ModEq.lean

tactic: decide
state_before: m n✝ a b c d n : ℕ
⊢ ∀ (m : ℕ), m < 4 → m % 2 = 1 → m = 1 ∨ m = 3

tactic: norm_num
state_before: m n✝ a b c d n : ℕ
help : ∀ (m : ℕ), m < 4 → m % 2 = 1 → m = 1 ∨ m = 3
hn : n % 2 = 1
⊢ 4 > 0

tactic: norm_num
state_before: m n✝ a b c d n : ℕ
help : ∀ (m : ℕ), m < 4 → m % 2 = 1 → m = 1 ∨ m = 3
hn : n % 2 = 1
⊢ 2 ∣ 4
Theorem: PrimeSpectrum.primeSpectrumProd_symm_inr_asIdeal
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: cases x
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
x : PrimeSpectrum S
⊢ (↑(primeSpectrumProd R S).symm (Sum.inr x)).asIdeal = Ideal.prod ⊤ x.asIdeal

tactic: rfl
state_before: case mk
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
asIdeal✝ : Ideal S
IsPrime✝ : Ideal.IsPrime asIdeal✝
⊢ (↑(primeSpectrumProd R S).symm (Sum.inr { asIdeal := asIdeal✝, IsPrime := IsPrime✝ })).asIdeal =
    Ideal.prod ⊤ { asIdeal := asIdeal✝, IsPrime := IsPrime✝ }.asIdeal
Theorem: Finset.filter_product_right
File: Mathlib/Data/Finset/Prod.lean

tactic: simpa using filter_product (fun _ : α => true) q
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.45778
s s' : Finset α
t t' : Finset β
a : α
b : β
q : β → Prop
inst✝ : DecidablePred q
⊢ filter (fun x => q x.snd) (s ×ˢ t) = s ×ˢ filter q t
Theorem: CategoryTheory.Limits.pullbackDiagonalMapIdIso_inv_fst
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

tactic: rw [Iso.inv_comp_eq, ← Category.comp_id pullback.fst, ← diagonal_fst i, pullback.condition_assoc]
state_before: C : Type u_2
inst✝⁵ : Category C
X Y Z : C
inst✝⁴ : HasPullbacks C
S T : C
f : X ⟶ T
g : Y ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f g
inst✝¹ : HasPullback (f ≫ i) (g ≫ i)
inst✝ :
  HasPullback (diagonal i) (map (f ≫ i) (g ≫ i) i i f g (𝟙 S) (_ : (f ≫ i) ≫ 𝟙 S = f ≫ i) (_ : (g ≫ i) ≫ 𝟙 S = g ≫ i))
⊢ (pullbackDiagonalMapIdIso f g i).inv ≫ fst = fst ≫ f

tactic: simp
state_before: C : Type u_2
inst✝⁵ : Category C
X Y Z : C
inst✝⁴ : HasPullbacks C
S T : C
f : X ⟶ T
g : Y ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f g
inst✝¹ : HasPullback (f ≫ i) (g ≫ i)
inst✝ :
  HasPullback (diagonal i) (map (f ≫ i) (g ≫ i) i i f g (𝟙 S) (_ : (f ≫ i) ≫ 𝟙 S = f ≫ i) (_ : (g ≫ i) ≫ 𝟙 S = g ≫ i))
⊢ snd ≫ map (f ≫ i) (g ≫ i) i i f g (𝟙 S) (_ : (f ≫ i) ≫ 𝟙 S = f ≫ i) (_ : (g ≫ i) ≫ 𝟙 S = g ≫ i) ≫ fst =
    (pullbackDiagonalMapIdIso f g i).hom ≫ fst ≫ f
Theorem: tendsto_comp_coe_Ioo_atBot
File: Mathlib/Topology/Order/Basic.lean

tactic: rw [← map_coe_Ioo_atBot h, tendsto_map'_iff]
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f : α → β
h : a < b
⊢ Tendsto (fun x => f ↑x) atBot l ↔ Tendsto f (𝓝[Ioi a] a) l

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f : α → β
h : a < b
⊢ Tendsto (fun x => f ↑x) atBot l ↔ Tendsto (f ∘ Subtype.val) atBot l
Theorem: Polynomial.separable_prod_X_sub_C_iff'
File: Mathlib/FieldTheory/Separable.lean

tactic: rw [← prod_attach]
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
ι : Type u_1
f : ι → F
s : Finset ι
H : ∀ (x : ι), x ∈ s → ∀ (y : ι), y ∈ s → f x = f y → x = y
⊢ Separable (∏ i in s, (X - ↑C (f i)))

tactic: exact
  separable_prod'
    (fun x _hx y _hy hxy =>
      @pairwise_coprime_X_sub_C _ _ { x // x ∈ s } (fun x => f x)
        (fun x y hxy => Subtype.eq <| H x.1 x.2 y.1 y.2 hxy) _ _ hxy)
    fun _ _ => separable_X_sub_C
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
ι : Type u_1
f : ι → F
s : Finset ι
H : ∀ (x : ι), x ∈ s → ∀ (y : ι), y ∈ s → f x = f y → x = y
⊢ Separable (∏ x in attach s, (X - ↑C (f ↑x)))
Theorem: Finset.card_le_card_biUnion
File: Mathlib/Algebra/BigOperators/Order.lean

tactic: rw [card_biUnion hs, card_eq_sum_ones]
state_before: ι : Type u_1
α : Type u_2
β : Type ?u.112113
M : Type ?u.112116
N : Type ?u.112119
G : Type ?u.112122
k : Type ?u.112125
R : Type ?u.112128
inst✝ : DecidableEq α
s✝ : Finset α
B : Finset (Finset α)
n : ℕ
s : Finset ι
f : ι → Finset α
hs : Set.PairwiseDisjoint (↑s) f
hf : ∀ (i : ι), i ∈ s → Finset.Nonempty (f i)
⊢ card s ≤ card (Finset.biUnion s f)

tactic: exact sum_le_sum fun i hi ↦ (hf i hi).card_pos
state_before: ι : Type u_1
α : Type u_2
β : Type ?u.112113
M : Type ?u.112116
N : Type ?u.112119
G : Type ?u.112122
k : Type ?u.112125
R : Type ?u.112128
inst✝ : DecidableEq α
s✝ : Finset α
B : Finset (Finset α)
n : ℕ
s : Finset ι
f : ι → Finset α
hs : Set.PairwiseDisjoint (↑s) f
hf : ∀ (i : ι), i ∈ s → Finset.Nonempty (f i)
⊢ ∑ x in s, 1 ≤ ∑ u in s, card (f u)
Theorem: irrational_int_div_iff
File: Mathlib/Data/Real/Irrational.lean

tactic: simp [div_eq_mul_inv]
state_before: q : ℚ
m : ℤ
n : ℕ
x : ℝ
⊢ Irrational (↑m / x) ↔ m ≠ 0 ∧ Irrational x
Theorem: real_inner_sub_sub_self
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: have : ⟪y, x⟫_ℝ = ⟪x, y⟫_ℝ := by rw [← inner_conj_symm]; rfl
state_before: 𝕜 : Type ?u.1810605
E : Type ?u.1810608
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : F
⊢ inner (x - y) (x - y) = inner x x - 2 * inner x y + inner y y

tactic: simp only [inner_sub_sub_self, this, add_left_inj]
state_before: 𝕜 : Type ?u.1810605
E : Type ?u.1810608
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : F
this : inner y x = inner x y
⊢ inner (x - y) (x - y) = inner x x - 2 * inner x y + inner y y

tactic: ring
state_before: 𝕜 : Type ?u.1810605
E : Type ?u.1810608
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : F
this : inner y x = inner x y
⊢ inner x x - inner x y - inner x y = inner x x - 2 * inner x y

tactic: rw [← inner_conj_symm]
state_before: 𝕜 : Type ?u.1810605
E : Type ?u.1810608
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : F
⊢ inner y x = inner x y

tactic: rfl
state_before: 𝕜 : Type ?u.1810605
E : Type ?u.1810608
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : F
⊢ ↑(starRingEnd ℝ) (inner x y) = inner x y
Theorem: Equiv.Perm.IsCycle.sameCycle
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rw [← ha, ← mul_apply, ← zpow_add, sub_add_cancel, hb]
state_before: ι : Type ?u.309988
α : Type u_1
β : Type ?u.309994
f g✝ : Perm α
x y : α
hf : IsCycle f
hx : ↑f x ≠ x
hy : ↑f y ≠ y
g : α
hg : ↑f g ≠ g ∧ ∀ ⦃y : α⦄, ↑f y ≠ y → SameCycle f g y
a : ℤ
ha : ↑(f ^ a) g = x
b : ℤ
hb : ↑(f ^ b) g = y
⊢ ↑(f ^ (b - a)) x = y
Theorem: EuclideanGeometry.mul_dist_eq_mul_dist_of_cospherical_of_angle_eq_pi
File: Mathlib/Geometry/Euclidean/Sphere/Power.lean

tactic: obtain ⟨-, k₁, _, hab⟩ := angle_eq_pi_iff.mp hapb
state_before: V : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_1
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapb : ∠ a p b = π
hcpd : ∠ c p d = π
⊢ dist a p * dist b p = dist c p * dist d p

tactic: obtain ⟨-, k₂, _, hcd⟩ := angle_eq_pi_iff.mp hcpd
state_before: case intro.intro.intro
V : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_1
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapb : ∠ a p b = π
hcpd : ∠ c p d = π
k₁ : ℝ
left✝ : k₁ < 0
hab : b -ᵥ p = k₁ • (a -ᵥ p)
⊢ dist a p * dist b p = dist c p * dist d p

tactic: exact mul_dist_eq_mul_dist_of_cospherical h ⟨k₁, by linarith, hab⟩ ⟨k₂, by linarith, hcd⟩
state_before: case intro.intro.intro.intro.intro.intro
V : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_1
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapb : ∠ a p b = π
hcpd : ∠ c p d = π
k₁ : ℝ
left✝¹ : k₁ < 0
hab : b -ᵥ p = k₁ • (a -ᵥ p)
k₂ : ℝ
left✝ : k₂ < 0
hcd : d -ᵥ p = k₂ • (c -ᵥ p)
⊢ dist a p * dist b p = dist c p * dist d p

tactic: linarith
state_before: V : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_1
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapb : ∠ a p b = π
hcpd : ∠ c p d = π
k₁ : ℝ
left✝¹ : k₁ < 0
hab : b -ᵥ p = k₁ • (a -ᵥ p)
k₂ : ℝ
left✝ : k₂ < 0
hcd : d -ᵥ p = k₂ • (c -ᵥ p)
⊢ k₁ ≠ 1

tactic: linarith
state_before: V : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
P : Type u_1
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c d p : P
h : Cospherical {a, b, c, d}
hapb : ∠ a p b = π
hcpd : ∠ c p d = π
k₁ : ℝ
left✝¹ : k₁ < 0
hab : b -ᵥ p = k₁ • (a -ᵥ p)
k₂ : ℝ
left✝ : k₂ < 0
hcd : d -ᵥ p = k₂ • (c -ᵥ p)
⊢ k₂ ≠ 1