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

tactic: rw [continuous_iff_le_induced, Pullback.TotalSpace.topologicalSpace, pullbackTopology_def]
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
⊢ Continuous TotalSpace.proj

tactic: exact inf_le_left
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
⊢ induced TotalSpace.proj inst✝¹ ⊓ induced (Pullback.lift f) inst✝ ≤ induced TotalSpace.proj inst✝¹
Theorem: Set.sInter_prod_sInter
File: Mathlib/Data/Set/Lattice.lean

tactic: obtain ⟨s₁, h₁⟩ := hS
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.238915
ι : Sort ?u.238918
ι' : Sort ?u.238921
ι₂ : Sort ?u.238924
κ : ι → Sort ?u.238929
κ₁ : ι → Sort ?u.238934
κ₂ : ι → Sort ?u.238939
κ' : ι' → Sort ?u.238944
S : Set (Set α)
T : Set (Set β)
hS : Set.Nonempty S
hT : Set.Nonempty T
⊢ ⋂₀ S ×ˢ ⋂₀ T = ⋂ (r : Set α × Set β) (_ : r ∈ S ×ˢ T), r.fst ×ˢ r.snd

tactic: obtain ⟨s₂, h₂⟩ := hT
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type ?u.238915
ι : Sort ?u.238918
ι' : Sort ?u.238921
ι₂ : Sort ?u.238924
κ : ι → Sort ?u.238929
κ₁ : ι → Sort ?u.238934
κ₂ : ι → Sort ?u.238939
κ' : ι' → Sort ?u.238944
S : Set (Set α)
T : Set (Set β)
hT : Set.Nonempty T
s₁ : Set α
h₁ : s₁ ∈ S
⊢ ⋂₀ S ×ˢ ⋂₀ T = ⋂ (r : Set α × Set β) (_ : r ∈ S ×ˢ T), r.fst ×ˢ r.snd

tactic: refine' Set.Subset.antisymm (sInter_prod_sInter_subset S T) fun x hx => _
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.238915
ι : Sort ?u.238918
ι' : Sort ?u.238921
ι₂ : Sort ?u.238924
κ : ι → Sort ?u.238929
κ₁ : ι → Sort ?u.238934
κ₂ : ι → Sort ?u.238939
κ' : ι' → Sort ?u.238944
S : Set (Set α)
T : Set (Set β)
s₁ : Set α
h₁ : s₁ ∈ S
s₂ : Set β
h₂ : s₂ ∈ T
⊢ ⋂₀ S ×ˢ ⋂₀ T = ⋂ (r : Set α × Set β) (_ : r ∈ S ×ˢ T), r.fst ×ˢ r.snd

tactic: rw [mem_iInter₂] at hx
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.238915
ι : Sort ?u.238918
ι' : Sort ?u.238921
ι₂ : Sort ?u.238924
κ : ι → Sort ?u.238929
κ₁ : ι → Sort ?u.238934
κ₂ : ι → Sort ?u.238939
κ' : ι' → Sort ?u.238944
S : Set (Set α)
T : Set (Set β)
s₁ : Set α
h₁ : s₁ ∈ S
s₂ : Set β
h₂ : s₂ ∈ T
x : α × β
hx : x ∈ ⋂ (r : Set α × Set β) (_ : r ∈ S ×ˢ T), r.fst ×ˢ r.snd
⊢ x ∈ ⋂₀ S ×ˢ ⋂₀ T

tactic: exact ⟨fun s₀ h₀ => (hx (s₀, s₂) ⟨h₀, h₂⟩).1, fun s₀ h₀ => (hx (s₁, s₀) ⟨h₁, h₀⟩).2⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.238915
ι : Sort ?u.238918
ι' : Sort ?u.238921
ι₂ : Sort ?u.238924
κ : ι → Sort ?u.238929
κ₁ : ι → Sort ?u.238934
κ₂ : ι → Sort ?u.238939
κ' : ι' → Sort ?u.238944
S : Set (Set α)
T : Set (Set β)
s₁ : Set α
h₁ : s₁ ∈ S
s₂ : Set β
h₂ : s₂ ∈ T
x : α × β
hx : ∀ (i : Set α × Set β), i ∈ S ×ˢ T → x ∈ i.fst ×ˢ i.snd
⊢ x ∈ ⋂₀ S ×ˢ ⋂₀ T
Theorem: MeasureTheory.FiniteMeasure.average_eq_integral_normalize
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

tactic: rw [μ.toMeasure_normalize_eq_of_nonzero nonzero, average]
state_before: Ω : Type u_2
inst✝³ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
nonzero : μ ≠ 0
f : Ω → E
⊢ average (↑μ) f = ∫ (ω : Ω), f ω ∂↑(normalize μ)

tactic: congr
state_before: Ω : Type u_2
inst✝³ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
nonzero : μ ≠ 0
f : Ω → E
⊢ (∫ (x : Ω), f x ∂(↑↑↑μ univ)⁻¹ • ↑μ) = ∫ (ω : Ω), f ω ∂↑((mass μ)⁻¹ • μ)

tactic: simp only [RingHom.toFun_eq_coe, ENNReal.coe_ofNNRealHom,
  ENNReal.coe_inv (μ.mass_nonzero_iff.mpr nonzero), ennreal_mass]
state_before: case e_μ.e_a
Ω : Type u_2
inst✝³ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
nonzero : μ ≠ 0
f : Ω → E
⊢ (↑↑↑μ univ)⁻¹ = ↑ENNReal.ofNNRealHom (mass μ)⁻¹
Theorem: isCoprime_self
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: rwa [mul_comm, add_mul]
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
x✝ : IsCoprime x x
a b : R
h : a * x + b * x = 1
⊢ x * (a + b) = 1

tactic: rwa [zero_mul, add_zero]
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
h : IsUnit x
b : R
hb : b * x = 1
⊢ b * x + 0 * x = 1
Theorem: CategoryTheory.IsIso.of_isIso_fac_right
File: Mathlib/CategoryTheory/Iso.lean

tactic: rw [← w] at hh
state_before: C : Type u
inst✝¹ : Category C
X✝ Y✝ Z✝ : C
f✝ g✝ : X✝ ⟶ Y✝
h✝ : Y✝ ⟶ Z✝
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : X ⟶ Z
inst✝ : IsIso g
hh : IsIso h
w : f ≫ g = h
⊢ IsIso f

tactic: haveI := hh
state_before: C : Type u
inst✝¹ : Category C
X✝ Y✝ Z✝ : C
f✝ g✝ : X✝ ⟶ Y✝
h✝ : Y✝ ⟶ Z✝
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : X ⟶ Z
inst✝ : IsIso g
hh : IsIso (f ≫ g)
w : f ≫ g = h
⊢ IsIso f

tactic: exact of_isIso_comp_right f g
state_before: C : Type u
inst✝¹ : Category C
X✝ Y✝ Z✝ : C
f✝ g✝ : X✝ ⟶ Y✝
h✝ : Y✝ ⟶ Z✝
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : X ⟶ Z
inst✝ : IsIso g
hh : IsIso (f ≫ g)
w : f ≫ g = h
this : IsIso (f ≫ g)
⊢ IsIso f
Theorem: Primrec.option_casesOn
File: Mathlib/Computability/Primrec.lean

tactic: cases' o a with b <;> simp [encodek]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.111139
δ : Type ?u.111142
σ : Type u_3
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
o : α → Option β
f : α → σ
g : α → β → σ
ho : Primrec o
hf : Primrec f
hg : Primrec₂ g
a : α
⊢ (Nat.casesOn (encode (o a)) (encode (f a)) fun b =>
      Nat.pred (encode (Option.bind (decode (encode (a, b).fst)) fun a => Option.map (g a) (decode b)))) =
    encode (Option.casesOn (o a) (f a) (g a))
Theorem: Ordinal.lift_down'
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: rw [card_type, ← Cardinal.lift_id'.{max u v, u} (#β), ← Cardinal.lift_umax.{u, v},
  lift_mk_eq.{u, max u v, max u v}] at e'
state_before: α✝ : Type ?u.112496
β✝ : Type ?u.112499
γ : Type ?u.112502
r : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
a : Cardinal
b : Ordinal
h : card b ≤ Cardinal.lift a
c : Cardinal
e : Cardinal.lift c = card b
α : Type u
β : Type (max u v)
s : β → β → Prop
x✝ : IsWellOrder β s
e' : Cardinal.lift (#α) = card (type s)
⊢ ∃ a', lift a' = type s

tactic: cases' e' with f
state_before: α✝ : Type ?u.112496
β✝ : Type ?u.112499
γ : Type ?u.112502
r : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
a : Cardinal
b : Ordinal
h : card b ≤ Cardinal.lift a
c : Cardinal
e : Cardinal.lift c = card b
α : Type u
β : Type (max u v)
s : β → β → Prop
x✝ : IsWellOrder β s
e' : Nonempty (α ≃ β)
⊢ ∃ a', lift a' = type s

tactic: have g := RelIso.preimage f s
state_before: case intro
α✝ : Type ?u.112496
β✝ : Type ?u.112499
γ : Type ?u.112502
r : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
a : Cardinal
b : Ordinal
h : card b ≤ Cardinal.lift a
c : Cardinal
e : Cardinal.lift c = card b
α : Type u
β : Type (max u v)
s : β → β → Prop
x✝ : IsWellOrder β s
f : α ≃ β
⊢ ∃ a', lift a' = type s

tactic: haveI := (g : f ⁻¹'o s ↪r s).isWellOrder
state_before: case intro
α✝ : Type ?u.112496
β✝ : Type ?u.112499
γ : Type ?u.112502
r : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
a : Cardinal
b : Ordinal
h : card b ≤ Cardinal.lift a
c : Cardinal
e : Cardinal.lift c = card b
α : Type u
β : Type (max u v)
s : β → β → Prop
x✝ : IsWellOrder β s
f : α ≃ β
g : ↑f ⁻¹'o s ≃r s
⊢ ∃ a', lift a' = type s

tactic: have := lift_type_eq.{u, max u v, max u v}.2 ⟨g⟩
state_before: case intro
α✝ : Type ?u.112496
β✝ : Type ?u.112499
γ : Type ?u.112502
r : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
a : Cardinal
b : Ordinal
h : card b ≤ Cardinal.lift a
c : Cardinal
e : Cardinal.lift c = card b
α : Type u
β : Type (max u v)
s : β → β → Prop
x✝ : IsWellOrder β s
f : α ≃ β
g : ↑f ⁻¹'o s ≃r s
this : IsWellOrder α (↑f ⁻¹'o s)
⊢ ∃ a', lift a' = type s

tactic: rw [lift_id, lift_umax.{u, v}] at this
state_before: case intro
α✝ : Type ?u.112496
β✝ : Type ?u.112499
γ : Type ?u.112502
r : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
a : Cardinal
b : Ordinal
h : card b ≤ Cardinal.lift a
c : Cardinal
e : Cardinal.lift c = card b
α : Type u
β : Type (max u v)
s : β → β → Prop
x✝ : IsWellOrder β s
f : α ≃ β
g : ↑f ⁻¹'o s ≃r s
this✝ : IsWellOrder α (↑f ⁻¹'o s)
this : lift (type (↑f ⁻¹'o s)) = lift (type s)
⊢ ∃ a', lift a' = type s

tactic: exact ⟨_, this⟩
state_before: case intro
α✝ : Type ?u.112496
β✝ : Type ?u.112499
γ : Type ?u.112502
r : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
a : Cardinal
b : Ordinal
h : card b ≤ Cardinal.lift a
c : Cardinal
e : Cardinal.lift c = card b
α : Type u
β : Type (max u v)
s : β → β → Prop
x✝ : IsWellOrder β s
f : α ≃ β
g : ↑f ⁻¹'o s ≃r s
this✝ : IsWellOrder α (↑f ⁻¹'o s)
this : lift (type (↑f ⁻¹'o s)) = type s
⊢ ∃ a', lift a' = type s
Theorem: ne₁₂_of_not_collinear
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: rintro rfl
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type ?u.306490
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ : P
h : ¬Collinear k {p₁, p₂, p₃}
⊢ p₁ ≠ p₂

tactic: simp [collinear_pair] at h
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type ?u.306490
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₃ : P
h : ¬Collinear k {p₁, p₁, p₃}
⊢ False
Theorem: UniformSpace.SeparationQuotient.uniformContinuous_lift
File: Mathlib/Topology/UniformSpace/Separation.lean

tactic: by_cases hf : UniformContinuous f
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace β
f : α → β
⊢ UniformContinuous (lift f)

tactic: rw [lift, dif_pos hf]
state_before: case pos
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace β
f : α → β
hf : UniformContinuous f
⊢ UniformContinuous (lift f)

tactic: exact uniformContinuous_quotient_lift hf
state_before: case pos
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace β
f : α → β
hf : UniformContinuous f
⊢ UniformContinuous (Quotient.lift f (_ : ∀ (x x_1 : α), x ≈ x_1 → f x = f x_1))

tactic: rw [lift, dif_neg hf]
state_before: case neg
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace β
f : α → β
hf : ¬UniformContinuous f
⊢ UniformContinuous (lift f)

tactic: exact uniformContinuous_of_const fun a _ => rfl
state_before: case neg
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace β
f : α → β
hf : ¬UniformContinuous f
⊢ UniformContinuous fun x => f (Nonempty.some (_ : Nonempty α))
Theorem: tendsto_const_smul_iff
File: Mathlib/Topology/Algebra/ConstMulAction.lean

tactic: simpa only [inv_smul_smul] using h.const_smul c⁻¹
state_before: M : Type ?u.30275
α : Type u_2
β : Type u_1
G : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : ContinuousConstSMul G α
f : β → α
l : Filter β
a : α
c : G
h : Tendsto (fun x => c • f x) l (𝓝 (c • a))
⊢ Tendsto f l (𝓝 a)
Theorem: Nat.add_div_of_dvd_right
File: Mathlib/Data/Nat/ModEq.lean

tactic: simp [h]
state_before: m n a✝ b✝ c✝ d a b c : ℕ
hca : c ∣ a
h : c = 0
⊢ (a + b) / c = a / c + b / c

tactic: rw [Nat.mod_eq_zero_of_dvd hca, zero_add]
state_before: m n a✝ b✝ c✝ d a b c : ℕ
hca : c ∣ a
h : ¬c = 0
⊢ a % c + b % c < c

tactic: exact Nat.mod_lt _ (pos_iff_ne_zero.mpr h)
state_before: m n a✝ b✝ c✝ d a b c : ℕ
hca : c ∣ a
h : ¬c = 0
⊢ b % c < c
Theorem: CauSeq.const_inv
File: Mathlib/Data/Real/CauSeq.lean

tactic: rwa [const_limZero]
state_before: α : Type ?u.201083
β : Type ?u.201086
inst✝² : LinearOrderedField α
inst✝¹ : DivisionRing β
abv : β → α
inst✝ : IsAbsoluteValue abv
x : β
hx : x ≠ 0
⊢ ¬LimZero (const abv x)
Theorem: Ideal.Filtration.submodule_span_single
File: Mathlib/RingTheory/Filtration.lean

tactic: rw [← Submodule.span_closure, submodule_closure_single, Submodule.coe_toAddSubmonoid]
state_before: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
h : Stable F
⊢ Submodule.span { x // x ∈ reesAlgebra I } (⋃ (i : ℕ), ↑(single R i) '' ↑(N F i)) = Filtration.submodule F

tactic: exact Submodule.span_eq (Filtration.submodule F)
state_before: R M : Type u
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
I : Ideal R
F F' : Filtration I M
h : Stable F
⊢ Submodule.span { x // x ∈ reesAlgebra I } ↑(Filtration.submodule F) = Filtration.submodule F
Theorem: Ordnode.findMax'_dual
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [← findMin'_dual, dual_dual]
state_before: α : Type u_1
t : Ordnode α
x : α
⊢ findMax' x (dual t) = findMin' t x
Theorem: Ordinal.mul_eq_zero'
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simp_rw [← type_prod_lex, type_eq_zero_iff_isEmpty]
state_before: α✝ : Type ?u.142517
β✝ : Type ?u.142520
γ : Type ?u.142523
r : α✝ → α✝ → Prop
s : β✝ → β✝ → Prop
t : γ → γ → Prop
a b : Ordinal
α : Type u_1
x✝³ : α → α → Prop
x✝² : IsWellOrder α x✝³
β : Type u_1
x✝¹ : β → β → Prop
x✝ : IsWellOrder β x✝¹
⊢ type x✝³ * type x✝¹ = 0 ↔ type x✝³ = 0 ∨ type x✝¹ = 0

tactic: rw [or_comm]
state_before: α✝ : Type ?u.142517
β✝ : Type ?u.142520
γ : Type ?u.142523
r : α✝ → α✝ → Prop
s : β✝ → β✝ → Prop
t : γ → γ → Prop
a b : Ordinal
α : Type u_1
x✝³ : α → α → Prop
x✝² : IsWellOrder α x✝³
β : Type u_1
x✝¹ : β → β → Prop
x✝ : IsWellOrder β x✝¹
⊢ IsEmpty (β × α) ↔ IsEmpty α ∨ IsEmpty β

tactic: exact isEmpty_prod
state_before: α✝ : Type ?u.142517
β✝ : Type ?u.142520
γ : Type ?u.142523
r : α✝ → α✝ → Prop
s : β✝ → β✝ → Prop
t : γ → γ → Prop
a b : Ordinal
α : Type u_1
x✝³ : α → α → Prop
x✝² : IsWellOrder α x✝³
β : Type u_1
x✝¹ : β → β → Prop
x✝ : IsWellOrder β x✝¹
⊢ IsEmpty (β × α) ↔ IsEmpty β ∨ IsEmpty α
Theorem: Set.pairwise_disjoint_Ioo_add_int_cast
File: Mathlib/Data/Set/Intervals/Group.lean

tactic: simpa only [zsmul_one, Int.cast_add, Int.cast_one, ← add_assoc] using
  pairwise_disjoint_Ioo_add_zsmul a (1 : α)
state_before: α : Type u_1
inst✝ : OrderedRing α
a : α
⊢ Pairwise (Disjoint on fun n => Ioo (a + ↑n) (a + ↑n + 1))
Theorem: Associates.FactorSet.coe_add
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: norm_cast
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
a b : Multiset { a // Irreducible a }
⊢ ↑(a + b) = ↑a + ↑b
Theorem: IsUpperSet.le_card_inter_finset
File: Mathlib/Combinatorics/SetFamily/HarrisKleitman.lean

tactic: rw [← isLowerSet_compl, ← coe_compl] at h𝒜
state_before: α : Type u_1
inst✝¹ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
inst✝ : Fintype α
h𝒜 : IsUpperSet ↑𝒜
hℬ : IsUpperSet ↑ℬ
⊢ card 𝒜 * card ℬ ≤ 2 ^ Fintype.card α * card (𝒜 ∩ ℬ)

tactic: have := h𝒜.card_inter_le_finset hℬ
state_before: α : Type u_1
inst✝¹ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
inst✝ : Fintype α
h𝒜✝ : IsLowerSet (↑𝒜ᶜ)
h𝒜 : IsLowerSet ↑(𝒜ᶜ)
hℬ : IsUpperSet ↑ℬ
⊢ card 𝒜 * card ℬ ≤ 2 ^ Fintype.card α * card (𝒜 ∩ ℬ)

tactic: rwa [card_compl, Fintype.card_finset, tsub_mul, le_tsub_iff_le_tsub, ← mul_tsub, ←
  card_sdiff (inter_subset_right _ _), sdiff_inter_self_right, sdiff_compl,
  _root_.inf_comm] at this
state_before: α : Type u_1
inst✝¹ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
inst✝ : Fintype α
h𝒜✝ : IsLowerSet (↑𝒜ᶜ)
h𝒜 : IsLowerSet ↑(𝒜ᶜ)
hℬ : IsUpperSet ↑ℬ
this : 2 ^ Fintype.card α * card (𝒜ᶜ ∩ ℬ) ≤ card (𝒜ᶜ) * card ℬ
⊢ card 𝒜 * card ℬ ≤ 2 ^ Fintype.card α * card (𝒜 ∩ ℬ)

tactic: exact mul_le_mul_left' (card_le_of_subset <| inter_subset_right _ _) _
state_before: case h₁
α : Type u_1
inst✝¹ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
inst✝ : Fintype α
h𝒜✝ : IsLowerSet (↑𝒜ᶜ)
h𝒜 : IsLowerSet ↑(𝒜ᶜ)
hℬ : IsUpperSet ↑ℬ
this : 2 ^ Fintype.card α * card (𝒜ᶜ ∩ ℬ) ≤ 2 ^ Fintype.card α * card ℬ - card 𝒜 * card ℬ
⊢ 2 ^ Fintype.card α * card (𝒜ᶜ ∩ ℬ) ≤ 2 ^ Fintype.card α * card ℬ

tactic: rw [← Fintype.card_finset]
state_before: case h₂
α : Type u_1
inst✝¹ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
inst✝ : Fintype α
h𝒜✝ : IsLowerSet (↑𝒜ᶜ)
h𝒜 : IsLowerSet ↑(𝒜ᶜ)
hℬ : IsUpperSet ↑ℬ
this : 2 ^ Fintype.card α * card (𝒜ᶜ ∩ ℬ) ≤ 2 ^ Fintype.card α * card ℬ - card 𝒜 * card ℬ
⊢ card 𝒜 * card ℬ ≤ 2 ^ Fintype.card α * card ℬ

tactic: exact mul_le_mul_right' (card_le_univ _) _
state_before: case h₂
α : Type u_1
inst✝¹ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
inst✝ : Fintype α
h𝒜✝ : IsLowerSet (↑𝒜ᶜ)
h𝒜 : IsLowerSet ↑(𝒜ᶜ)
hℬ : IsUpperSet ↑ℬ
this : 2 ^ Fintype.card α * card (𝒜ᶜ ∩ ℬ) ≤ 2 ^ Fintype.card α * card ℬ - card 𝒜 * card ℬ
⊢ card 𝒜 * card ℬ ≤ Fintype.card (Finset α) * card ℬ
Theorem: edist_le_of_edist_le_geometric_two_of_tendsto₀
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: simpa only [_root_.pow_zero, div_eq_mul_inv, inv_one, mul_one] using
  edist_le_of_edist_le_geometric_two_of_tendsto C hu ha 0
state_before: α : Type u_1
β : Type ?u.444903
ι : Type ?u.444906
inst✝ : PseudoEMetricSpace α
C : ℝ≥0∞
hC : C ≠ ⊤
f : ℕ → α
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C / 2 ^ n
a : α
ha : Tendsto f atTop (𝓝 a)
⊢ edist (f 0) a ≤ 2 * C
Theorem: PGame.neg_equiv_neg_iff
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [Equiv, Equiv, neg_le_neg_iff, neg_le_neg_iff, and_comm]
state_before: x y : PGame
⊢ (-x ≈ -y) ↔ (x ≈ y)
Theorem: Ordnode.Bounded.weak_left
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: cases o₂ <;> trivial
state_before: α : Type u_1
inst✝ : Preorder α
o₁ : WithBot α
o₂ : WithTop α
h : Bounded nil o₁ o₂
⊢ Bounded nil ⊥ o₂
Theorem: Matrix.one_mul
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.315980
m : Type u_1
n : Type u_2
o : Type ?u.315989
m' : o → Type ?u.315994
n' : o → Type ?u.315999
R : Type ?u.316002
S : Type ?u.316005
α : Type v
β : Type w
γ : Type ?u.316012
inst✝² : NonAssocSemiring α
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n α
⊢ 1 ⬝ M = M

tactic: rw [← diagonal_one, diagonal_mul, one_mul]
state_before: case a.h
l : Type ?u.315980
m : Type u_1
n : Type u_2
o : Type ?u.315989
m' : o → Type ?u.315994
n' : o → Type ?u.315999
R : Type ?u.316002
S : Type ?u.316005
α : Type v
β : Type w
γ : Type ?u.316012
inst✝² : NonAssocSemiring α
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n α
i✝ : m
x✝ : n
⊢ (1 ⬝ M) i✝ x✝ = M i✝ x✝
Theorem: Nat.Partrec.Code.eval_prec_zero
File: Mathlib/Computability/PartrecCode.lean

tactic: rw [eval, Nat.unpaired, Nat.unpair_pair]
state_before: cf cg : Code
a : ℕ
⊢ eval (prec cf cg) (Nat.pair a 0) = eval cf a

tactic: simp (config := { Lean.Meta.Simp.neutralConfig with proj := true }) only []
state_before: cf cg : Code
a : ℕ
⊢ Nat.rec (eval cf (a, 0).fst)
      (fun y IH => do
        let i ← IH
        eval cg (Nat.pair (a, 0).fst (Nat.pair y i)))
      (a, 0).snd =
    eval cf a

tactic: rw [Nat.rec_zero]
state_before: cf cg : Code
a : ℕ
⊢ Nat.rec (eval cf a)
      (fun y IH => do
        let i ← IH
        eval cg (Nat.pair a (Nat.pair y i)))
      0 =
    eval cf a
Theorem: sInfHom.continuous
File: Mathlib/Topology/Order/LowerTopology.lean

tactic: refine LowerTopology.continuous_of_Ici fun b => ?_
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : CompleteLattice α
inst✝⁴ : CompleteLattice β
inst✝³ : TopologicalSpace α
inst✝² : LowerTopology α
inst✝¹ : TopologicalSpace β
inst✝ : LowerTopology β
f : sInfHom α β
⊢ Continuous ↑f

tactic: convert LowerTopology.isClosed_Ici (sInf <| f ⁻¹' Ici b)
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : CompleteLattice α
inst✝⁴ : CompleteLattice β
inst✝³ : TopologicalSpace α
inst✝² : LowerTopology α
inst✝¹ : TopologicalSpace β
inst✝ : LowerTopology β
f : sInfHom α β
b : β
⊢ IsClosed (↑f ⁻¹' Ici b)

tactic: refine' Subset.antisymm (fun a => sInf_le) fun a ha => le_trans _ <|
  OrderHomClass.mono (f : α →o β) ha
state_before: case h.e'_3
α : Type u_1
β : Type u_2
inst✝⁵ : CompleteLattice α
inst✝⁴ : CompleteLattice β
inst✝³ : TopologicalSpace α
inst✝² : LowerTopology α
inst✝¹ : TopologicalSpace β
inst✝ : LowerTopology β
f : sInfHom α β
b : β
⊢ ↑f ⁻¹' Ici b = Ici (sInf (↑f ⁻¹' Ici b))

tactic: refine' LE.le.trans _ (map_sInf f _).ge
state_before: case h.e'_3
α : Type u_1
β : Type u_2
inst✝⁵ : CompleteLattice α
inst✝⁴ : CompleteLattice β
inst✝³ : TopologicalSpace α
inst✝² : LowerTopology α
inst✝¹ : TopologicalSpace β
inst✝ : LowerTopology β
f : sInfHom α β
b : β
a : α
ha : a ∈ Ici (sInf (↑f ⁻¹' Ici b))
⊢ b ≤ ↑↑f (sInf (↑f ⁻¹' Ici b))

tactic: simp
state_before: case h.e'_3
α : Type u_1
β : Type u_2
inst✝⁵ : CompleteLattice α
inst✝⁴ : CompleteLattice β
inst✝³ : TopologicalSpace α
inst✝² : LowerTopology α
inst✝¹ : TopologicalSpace β
inst✝ : LowerTopology β
f : sInfHom α β
b : β
a : α
ha : a ∈ Ici (sInf (↑f ⁻¹' Ici b))
⊢ b ≤ sInf (↑f '' (↑f ⁻¹' Ici b))
Theorem: Int.lt_sub_left_of_add_lt
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.add_lt_add_right h (-a)
state_before: a b c : Int
h : a + b < c
⊢ b < c - a

tactic: rwa [Int.add_comm a b, Int.add_neg_cancel_right] at h
state_before: a b c : Int
h✝ : a + b < c
h : a + b + -a < c + -a
⊢ b < c - a
Theorem: IsNilpotent.map
File: Mathlib/RingTheory/Nilpotent.lean

tactic: use hr.choose
state_before: R S : Type u
x y : R
inst✝² : MonoidWithZero R
inst✝¹ : MonoidWithZero S
r : R
F : Type u_1
inst✝ : MonoidWithZeroHomClass F R S
hr : IsNilpotent r
f : F
⊢ IsNilpotent (↑f r)

tactic: rw [← map_pow, hr.choose_spec, map_zero]
state_before: R S : Type u
x y : R
inst✝² : MonoidWithZero R
inst✝¹ : MonoidWithZero S
r : R
F : Type u_1
inst✝ : MonoidWithZeroHomClass F R S
hr : IsNilpotent r
f : F
⊢ ↑f r ^ Exists.choose hr = 0
Theorem: MeasureTheory.AEDisjoint.symm
File: Mathlib/MeasureTheory/Measure/AEDisjoint.lean

tactic: rwa [AEDisjoint, inter_comm]
state_before: ι : Type ?u.3489
α : Type u_1
m : MeasurableSpace α
μ : Measure α
s t u v : Set α
h : AEDisjoint μ s t
⊢ AEDisjoint μ t s
Theorem: tsum_eq_zero_of_not_summable
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: simp [tsum_def, h]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.19688
δ : Type ?u.19691
inst✝¹ : AddCommMonoid α
inst✝ : TopologicalSpace α
f g : β → α
a b : α
s : Finset β
h : ¬Summable f
⊢ (∑' (b : β), f b) = 0
Theorem: WittVector.constantCoeff_wittNeg
File: Mathlib/RingTheory/WittVector/Defs.lean

tactic: apply constantCoeff_wittStructureInt p _ _ n
state_before: p : ℕ
R : Type ?u.144931
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
n : ℕ
⊢ ↑constantCoeff (wittNeg p n) = 0

tactic: simp only [neg_zero, RingHom.map_neg, constantCoeff_X]
state_before: p : ℕ
R : Type ?u.144931
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
n : ℕ
⊢ ↑constantCoeff (-X 0) = 0
Theorem: exists_eq_right_right
File: Std/Logic.lean

tactic: simp [← and_assoc]
state_before: α : Sort u_1
p q : α → Prop
b : Prop
a' : α
⊢ (∃ a, p a ∧ b ∧ a = a') ↔ p a' ∧ b
Theorem: Int.testBit_succ
File: Mathlib/Data/Int/Bitwise.lean

tactic: rw [bit_coe_nat]
state_before: m : ℕ
b : Bool
n : ℕ
⊢ testBit (bit b ↑n) (Nat.succ m) = testBit (↑n) m

tactic: apply Nat.testBit_succ
state_before: m : ℕ
b : Bool
n : ℕ
⊢ testBit (↑(Nat.bit b n)) (Nat.succ m) = testBit (↑n) m

tactic: dsimp [testBit]
state_before: m : ℕ
b : Bool
n : ℕ
⊢ testBit (bit b -[n+1]) (Nat.succ m) = testBit -[n+1] m

tactic: simp only [bit_negSucc]
state_before: m : ℕ
b : Bool
n : ℕ
⊢ (match bit b -[n+1], Nat.succ m with
    | ofNat m, n => Nat.testBit m n
    | -[m+1], n => !Nat.testBit m n) =
    !Nat.testBit n m

tactic: cases b <;> simp [Nat.testBit_succ]
state_before: m : ℕ
b : Bool
n : ℕ
⊢ (!Nat.testBit (Nat.bit (!b) n) (Nat.succ m)) = !Nat.testBit n m
Theorem: AffineBasis.basisOf_apply
File: Mathlib/LinearAlgebra/AffineSpace/Basis.lean

tactic: simp [basisOf]
state_before: ι : Type u_1
ι' : Type ?u.48727
k : Type u_3
V : Type u_2
P : Type u_4
inst✝³ : AddCommGroup V
inst✝² : AffineSpace V P
inst✝¹ : Ring k
inst✝ : Module k V
b : AffineBasis ι k P
s : Finset ι
i✝ j✝ : ι
e : ι ≃ ι'
i : ι
j : { j // j ≠ i }
⊢ ↑(basisOf b i) j = ↑b ↑j -ᵥ ↑b i